diff --git a/index.html b/index.html index 67c609f..0a38f8b 100644 --- a/index.html +++ b/index.html @@ -20,10 +20,9 @@

Projects

- Peristaltic Pump - Factor diagrams! - A (boring) visualisation of a sorting algorithm in JS - + Peristaltic Pump
+ Factor diagrams!
+ A (boring) visualisation of a sorting algorithm in JS
diff --git a/underscore/.gitignore b/underscore/.gitignore new file mode 100644 index 0000000..48ecc30 --- /dev/null +++ b/underscore/.gitignore @@ -0,0 +1 @@ +raw \ No newline at end of file diff --git a/underscore/.npmignore b/underscore/.npmignore new file mode 100644 index 0000000..2ce2684 --- /dev/null +++ b/underscore/.npmignore @@ -0,0 +1,3 @@ +test/ +Rakefile +docs/ \ No newline at end of file diff --git a/underscore/CNAME b/underscore/CNAME new file mode 100644 index 0000000..a007e65 --- /dev/null +++ b/underscore/CNAME @@ -0,0 +1 @@ +underscorejs.org diff --git a/underscore/CONTRIBUTING.md b/underscore/CONTRIBUTING.md new file mode 100644 index 0000000..36a9934 --- /dev/null +++ b/underscore/CONTRIBUTING.md @@ -0,0 +1,9 @@ +## How to contribute to Underscore.js + +* Before you open a ticket or send a pull request, [search](https://github.com/documentcloud/underscore/issues) for previous discussions about the same feature or issue. Add to the earlier ticket if you find one. + +* Before sending a pull request for a feature, be sure to have [tests](http://underscorejs.org/test/test.html). + +* Use the same coding style as the rest of the [codebase](https://github.com/documentcloud/underscore/blob/master/underscore.js). + +* In your pull request, do not add documentation or re-build the minified `underscore-min.js` file. We'll do those things before cutting a new release. \ No newline at end of file diff --git a/underscore/LICENSE b/underscore/LICENSE new file mode 100644 index 0000000..61d28c0 --- /dev/null +++ b/underscore/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2009-2012 Jeremy Ashkenas, DocumentCloud + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN 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. \ No newline at end of file diff --git a/underscore/README.md b/underscore/README.md new file mode 100644 index 0000000..b1f3e50 --- /dev/null +++ b/underscore/README.md @@ -0,0 +1,19 @@ + __ + /\ \ __ + __ __ ___ \_\ \ __ _ __ ____ ___ ___ _ __ __ /\_\ ____ + /\ \/\ \ /' _ `\ /'_ \ /'__`\/\ __\/ ,__\ / ___\ / __`\/\ __\/'__`\ \/\ \ /',__\ + \ \ \_\ \/\ \/\ \/\ \ \ \/\ __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\ __/ __ \ \ \/\__, `\ + \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/ + \/___/ \/_/\/_/\/__,_ /\/____/ \/_/ \/___/ \/____/\/___/ \/_/ \/____/\/_//\ \_\ \/___/ + \ \____/ + \/___/ + +Underscore.js is a utility-belt library for JavaScript that provides +support for the usual functional suspects (each, map, reduce, filter...) +without extending any core JavaScript objects. + +For Docs, License, Tests, and pre-packed downloads, see: +http://underscorejs.org + +Many thanks to our contributors: +https://github.com/documentcloud/underscore/contributors diff --git a/underscore/Rakefile b/underscore/Rakefile new file mode 100644 index 0000000..b9fd1ca --- /dev/null +++ b/underscore/Rakefile @@ -0,0 +1,15 @@ +require 'rubygems' +require 'uglifier' + +desc "Use the Closure Compiler to compress Underscore.js" +task :build do + source = File.read('underscore.js') + min = Uglifier.compile(source) + File.open('underscore-min.js', 'w') {|f| f.write min } +end + +desc "Build the docco documentation" +task :doc do + sh "docco underscore.js" +end + diff --git a/underscore/docs/docco.css b/underscore/docs/docco.css new file mode 100644 index 0000000..04cc7ec --- /dev/null +++ b/underscore/docs/docco.css @@ -0,0 +1,192 @@ +/*--------------------- Layout and Typography ----------------------------*/ +body { + font-family: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif; + font-size: 15px; + line-height: 22px; + color: #252519; + margin: 0; padding: 0; +} +a { + color: #261a3b; +} + a:visited { + color: #261a3b; + } +p { + margin: 0 0 15px 0; +} +h1, h2, h3, h4, h5, h6 { + margin: 0px 0 15px 0; +} + h1 { + margin-top: 40px; + } +hr { + border: 0 none; + border-top: 1px solid #e5e5ee; + height: 1px; + margin: 20px 0; +} +#container { + position: relative; +} +#background { + position: fixed; + top: 0; left: 525px; right: 0; bottom: 0; + background: #f5f5ff; + border-left: 1px solid #e5e5ee; + z-index: -1; +} +#jump_to, #jump_page { + background: white; + -webkit-box-shadow: 0 0 25px #777; -moz-box-shadow: 0 0 25px #777; + -webkit-border-bottom-left-radius: 5px; -moz-border-radius-bottomleft: 5px; + font: 10px Arial; + text-transform: uppercase; + cursor: pointer; + text-align: right; +} +#jump_to, #jump_wrapper { + position: fixed; + right: 0; top: 0; + padding: 5px 10px; +} + #jump_wrapper { + padding: 0; + display: none; + } + #jump_to:hover #jump_wrapper { + display: block; + } + #jump_page { + padding: 5px 0 3px; + margin: 0 0 25px 25px; + } + #jump_page .source { + display: block; + padding: 5px 10px; + text-decoration: none; + border-top: 1px solid #eee; + } + #jump_page .source:hover { + background: #f5f5ff; + } + #jump_page .source:first-child { + } +table td { + border: 0; + outline: 0; +} + td.docs, th.docs { + max-width: 450px; + min-width: 450px; + min-height: 5px; + padding: 10px 25px 1px 50px; + overflow-x: hidden; + vertical-align: top; + text-align: left; + } + .docs pre { + margin: 15px 0 15px; + padding-left: 15px; + } + .docs p tt, .docs p code { + background: #f8f8ff; + border: 1px solid #dedede; + font-size: 12px; + padding: 0 0.2em; + } + .pilwrap { + position: relative; + } + .pilcrow { + font: 12px Arial; + text-decoration: none; + color: #454545; + position: absolute; + top: 3px; left: -20px; + padding: 1px 2px; + opacity: 0; + -webkit-transition: opacity 0.2s linear; + } + td.docs:hover .pilcrow { + opacity: 1; + } + td.code, th.code { + padding: 14px 15px 16px 25px; + width: 100%; + vertical-align: top; + background: #f5f5ff; + border-left: 1px solid #e5e5ee; + } + pre, tt, code { + font-size: 12px; line-height: 18px; + font-family: Menlo, Monaco, Consolas, "Lucida Console", monospace; + margin: 0; padding: 0; + } + + +/*---------------------- Syntax Highlighting -----------------------------*/ +td.linenos { background-color: #f0f0f0; padding-right: 10px; } +span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; } +body .hll { background-color: #ffffcc } +body .c { color: #408080; font-style: italic } /* Comment */ +body .err { border: 1px solid #FF0000 } /* Error */ +body .k { color: #954121 } /* Keyword */ +body .o { color: #666666 } /* Operator */ +body .cm { color: #408080; font-style: italic } /* Comment.Multiline */ +body .cp { color: #BC7A00 } /* Comment.Preproc */ +body .c1 { color: #408080; font-style: italic } /* Comment.Single */ +body .cs { color: #408080; font-style: italic } /* Comment.Special */ +body .gd { color: #A00000 } /* Generic.Deleted */ +body .ge { font-style: italic } /* Generic.Emph */ +body .gr { color: #FF0000 } /* Generic.Error */ +body .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +body .gi { color: #00A000 } /* Generic.Inserted */ +body .go { color: #808080 } /* Generic.Output */ +body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +body .gs { font-weight: bold } /* Generic.Strong */ +body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +body .gt { color: #0040D0 } /* Generic.Traceback */ +body .kc { color: #954121 } /* Keyword.Constant */ +body .kd { color: #954121; font-weight: bold } /* Keyword.Declaration */ +body .kn { color: #954121; font-weight: bold } /* Keyword.Namespace */ +body .kp { color: #954121 } /* Keyword.Pseudo */ +body .kr { color: #954121; font-weight: bold } /* Keyword.Reserved */ +body .kt { color: #B00040 } /* Keyword.Type */ +body .m { color: #666666 } /* Literal.Number */ +body .s { color: #219161 } /* Literal.String */ +body .na { color: #7D9029 } /* Name.Attribute */ +body .nb { color: #954121 } /* Name.Builtin */ +body .nc { color: #0000FF; font-weight: bold } /* Name.Class */ +body .no { color: #880000 } /* Name.Constant */ +body .nd { color: #AA22FF } /* Name.Decorator */ +body .ni { color: #999999; font-weight: bold } /* Name.Entity */ +body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */ +body .nf { color: #0000FF } /* Name.Function */ +body .nl { color: #A0A000 } /* Name.Label */ +body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */ +body .nt { color: #954121; font-weight: bold } /* Name.Tag */ +body .nv { color: #19469D } /* Name.Variable */ +body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */ +body .w { color: #bbbbbb } /* Text.Whitespace */ +body .mf { color: #666666 } /* Literal.Number.Float */ +body .mh { color: #666666 } /* Literal.Number.Hex */ +body .mi { color: #666666 } /* Literal.Number.Integer */ +body .mo { color: #666666 } /* Literal.Number.Oct */ +body .sb { color: #219161 } /* Literal.String.Backtick */ +body .sc { color: #219161 } /* Literal.String.Char */ +body .sd { color: #219161; font-style: italic } /* Literal.String.Doc */ +body .s2 { color: #219161 } /* Literal.String.Double */ +body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */ +body .sh { color: #219161 } /* Literal.String.Heredoc */ +body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */ +body .sx { color: #954121 } /* Literal.String.Other */ +body .sr { color: #BB6688 } /* Literal.String.Regex */ +body .s1 { color: #219161 } /* Literal.String.Single */ +body .ss { color: #19469D } /* Literal.String.Symbol */ +body .bp { color: #954121 } /* Name.Builtin.Pseudo */ +body .vc { color: #19469D } /* Name.Variable.Class */ +body .vg { color: #19469D } /* Name.Variable.Global */ +body .vi { color: #19469D } /* Name.Variable.Instance */ +body .il { color: #666666 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/underscore/docs/favicon.ico b/underscore/docs/favicon.ico new file mode 100644 index 0000000..0304968 Binary files /dev/null and b/underscore/docs/favicon.ico differ diff --git a/underscore/docs/images/background.png b/underscore/docs/images/background.png new file mode 100644 index 0000000..90ee693 Binary files /dev/null and b/underscore/docs/images/background.png differ diff --git a/underscore/docs/images/underscore.png b/underscore/docs/images/underscore.png new file mode 100644 index 0000000..dce9edb Binary files /dev/null and b/underscore/docs/images/underscore.png differ diff --git a/underscore/docs/underscore.html b/underscore/docs/underscore.html new file mode 100644 index 0000000..1f4b86a --- /dev/null +++ b/underscore/docs/underscore.html @@ -0,0 +1,800 @@ + underscore.js

underscore.js 

Underscore.js 1.4.2
+http://underscorejs.org
+(c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+Underscore may be freely distributed under the MIT license.
+
 
(function() {

Baseline setup

 
             		           
                               
                            
                                
               
Establish the root object, window in the browser, or global on the server.
             		                            
  var root = this;
             		           
                               
                            
                                
               
Save the previous value of the _ variable.
             		                            
  var previousUnderscore = root._;
             		           
                               
                            
                                
               
Establish the object that gets returned to break out of a loop iteration.
             		                            
  var breaker = {};
             		           
                               
                            
                                
               
Save bytes in the minified (but not gzipped) version:
             		                            
  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
             		           
                               
                            
                                
               
Create quick reference variables for speed access to core prototypes.
             		                            
  var push             = ArrayProto.push,
+      slice            = ArrayProto.slice,
+      concat           = ArrayProto.concat,
+      unshift          = ArrayProto.unshift,
+      toString         = ObjProto.toString,
+      hasOwnProperty   = ObjProto.hasOwnProperty;
             		           
                               
                            
                                
               
All ECMAScript 5 native function implementations that we hope to use
+are declared here.
             		                            
  var
+    nativeForEach      = ArrayProto.forEach,
+    nativeMap          = ArrayProto.map,
+    nativeReduce       = ArrayProto.reduce,
+    nativeReduceRight  = ArrayProto.reduceRight,
+    nativeFilter       = ArrayProto.filter,
+    nativeEvery        = ArrayProto.every,
+    nativeSome         = ArrayProto.some,
+    nativeIndexOf      = ArrayProto.indexOf,
+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
+    nativeIsArray      = Array.isArray,
+    nativeKeys         = Object.keys,
+    nativeBind         = FuncProto.bind;
             		           
                               
                            
                                
               
Create a safe reference to the Underscore object for use below.
             		                            
  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
             		           
                               
                            
                                
               
Export the Underscore object for Node.js, with
+backwards-compatibility for the old require() API. If we're in
+the browser, add _ as a global object via a string identifier,
+for Closure Compiler "advanced" mode.
             		                            
  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = _;
+    }
+    exports._ = _;
+  } else {
+    root['_'] = _;
+  }
             		           
                               
                            
                                
               
Current version.
             		                            
  _.VERSION = '1.4.2';
             		           
                               
                            
                                
               
Collection Functions
             		                            
             		           
                               
                            
                                
               
The cornerstone, an each implementation, aka forEach.
+Handles objects with the built-in forEach, arrays, and raw objects.
+Delegates to ECMAScript 5's native forEach if available.
             		                            
  var each = _.each = _.forEach = function(obj, iterator, context) {
+    if (obj == null) return;
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (var i = 0, l = obj.length; i < l; i++) {
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
+      }
+    } else {
+      for (var key in obj) {
+        if (_.has(obj, key)) {
+          if (iterator.call(context, obj[key], key, obj) === breaker) return;
+        }
+      }
+    }
+  };
             		           
                               
                            
                                
               
Return the results of applying the iterator to each element.
+Delegates to ECMAScript 5's native map if available.
             		                            
  _.map = _.collect = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+    each(obj, function(value, index, list) {
+      results[results.length] = iterator.call(context, value, index, list);
+    });
+    return results;
+  };
             		           
                               
                            
                                
               
Reduce builds up a single result from a list of values, aka inject,
+or foldl. Delegates to ECMAScript 5's native reduce if available.
             		                            
  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduce && obj.reduce === nativeReduce) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+    }
+    each(obj, function(value, index, list) {
+      if (!initial) {
+        memo = value;
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, value, index, list);
+      }
+    });
+    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+    return memo;
+  };
             		           
                               
                            
                                
               
The right-associative version of reduce, also known as foldr.
+Delegates to ECMAScript 5's native reduceRight if available.
             		                            
  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+      if (context) iterator = _.bind(iterator, context);
+      return arguments.length > 2 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+    }
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+    return memo;
+  };
             		           
                               
                            
                                
               
Return the first value which passes a truth test. Aliased as detect.
             		                            
  _.find = _.detect = function(obj, iterator, context) {
+    var result;
+    any(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) {
+        result = value;
+        return true;
+      }
+    });
+    return result;
+  };
             		           
                               
                            
                                
               
Return all the elements that pass a truth test.
+Delegates to ECMAScript 5's native filter if available.
+Aliased as select.
             		                            
  _.filter = _.select = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+    each(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) results[results.length] = value;
+    });
+    return results;
+  };
             		           
                               
                            
                                
               
Return all the elements for which a truth test fails.
             		                            
  _.reject = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    each(obj, function(value, index, list) {
+      if (!iterator.call(context, value, index, list)) results[results.length] = value;
+    });
+    return results;
+  };
             		           
                               
                            
                                
               
Determine whether all of the elements match a truth test.
+Delegates to ECMAScript 5's native every if available.
+Aliased as all.
             		                            
  _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = true;
+    if (obj == null) return result;
+    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+    each(obj, function(value, index, list) {
+      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
             		           
                               
                            
                                
               
Determine if at least one element in the object matches a truth test.
+Delegates to ECMAScript 5's native some if available.
+Aliased as any.
             		                            
  var any = _.some = _.any = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = false;
+    if (obj == null) return result;
+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+    each(obj, function(value, index, list) {
+      if (result || (result = iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
             		           
                               
                            
                                
               
Determine if the array or object contains a given value (using ===).
+Aliased as include.
             		                            
  _.contains = _.include = function(obj, target) {
+    var found = false;
+    if (obj == null) return found;
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+    found = any(obj, function(value) {
+      return value === target;
+    });
+    return found;
+  };
             		           
                               
                            
                                
               
Invoke a method (with arguments) on every item in a collection.
             		                            
  _.invoke = function(obj, method) {
+    var args = slice.call(arguments, 2);
+    return _.map(obj, function(value) {
+      return (_.isFunction(method) ? method : value[method]).apply(value, args);
+    });
+  };
             		           
                               
                            
                                
               
Convenience version of a common use case of map: fetching a property.
             		                            
  _.pluck = function(obj, key) {
+    return _.map(obj, function(value){ return value[key]; });
+  };
             		           
                               
                            
                                
               
Convenience version of a common use case of filter: selecting only objects
+with specific key:value pairs.
             		                            
  _.where = function(obj, attrs) {
+    if (_.isEmpty(attrs)) return [];
+    return _.filter(obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
             		           
                               
                            
                                
               
Return the maximum element or (element-based computation).
+Can't optimize arrays of integers longer than 65,535 elements.
+See: https://bugs.webkit.org/show_bug.cgi?id=80797
             		                            
  _.max = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return -Infinity;
+    var result = {computed : -Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed >= result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
             		           
                               
                            
                                
               
Return the minimum element (or element-based computation).
             		                            
  _.min = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return Infinity;
+    var result = {computed : Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed < result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
             		           
                               
                            
                                
               
Shuffle an array.
             		                            
  _.shuffle = function(obj) {
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
+    });
+    return shuffled;
+  };
             		           
                               
                            
                                
               
An internal function to generate lookup iterators.
             		                            
  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
             		           
                               
                            
                                
               
Sort the object's values by a criterion produced by an iterator.
             		                            
  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
+    return _.pluck(_.map(obj, function(value, index, list) {
+      return {
+        value : value,
+        index : index,
+        criteria : iterator.call(context, value, index, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index < right.index ? -1 : 1;
+    }), 'value');
+  };
             		           
                               
                            
                                
               
An internal function used for aggregate "group by" operations.
             		                            
  var group = function(obj, value, context, behavior) {
+    var result = {};
+    var iterator = lookupIterator(value);
+    each(obj, function(value, index) {
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
+    });
+    return result;
+  };
             		           
                               
                            
                                
               
Groups the object's values by a criterion. Pass either a string attribute
+to group by, or a function that returns the criterion.
             		                            
  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+    });
+  };
             		           
                               
                            
                                
               
Counts instances of an object that group by a certain criterion. Pass
+either a string attribute to count by, or a function that returns the
+criterion.
             		                            
  _.countBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
             		           
                               
                            
                                
               
Use a comparator function to figure out the smallest index at which
+an object should be inserted so as to maintain order. Uses binary search.
             		                            
  _.sortedIndex = function(array, obj, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
+    var low = 0, high = array.length;
+    while (low < high) {
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+    }
+    return low;
+  };
             		           
                               
                            
                                
               
Safely convert anything iterable into a real, live array.
             		                            
  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (obj.length === +obj.length) return slice.call(obj);
+    return _.values(obj);
+  };
             		           
                               
                            
                                
               
Return the number of elements in an object.
             		                            
  _.size = function(obj) {
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+  };
             		           
                               
                            
                                
               
Array Functions
             		                            
             		           
                               
                            
                                
               
Get the first element of an array. Passing n will return the first N
+values in the array. Aliased as head and take. The guard check
+allows it to work with _.map.
             		                            
  _.first = _.head = _.take = function(array, n, guard) {
+    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+  };
             		           
                               
                            
                                
               
Returns everything but the last entry of the array. Especially useful on
+the arguments object. Passing n will return all the values in
+the array, excluding the last N. The guard check allows it to work with
+_.map.
             		                            
  _.initial = function(array, n, guard) {
+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+  };
             		           
                               
                            
                                
               
Get the last element of an array. Passing n will return the last N
+values in the array. The guard check allows it to work with _.map.
             		                            
  _.last = function(array, n, guard) {
+    if ((n != null) && !guard) {
+      return slice.call(array, Math.max(array.length - n, 0));
+    } else {
+      return array[array.length - 1];
+    }
+  };
             		           
                               
                            
                                
               
Returns everything but the first entry of the array. Aliased as tail and drop.
+Especially useful on the arguments object. Passing an n will return
+the rest N values in the array. The guard
+check allows it to work with _.map.
             		                            
  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
+  };
             		           
                               
                            
                                
               
Trim out all falsy values from an array.
             		                            
  _.compact = function(array) {
+    return _.filter(array, function(value){ return !!value; });
+  };
             		           
                               
                            
                                
               
Internal implementation of a recursive flatten function.
             		                            
  var flatten = function(input, shallow, output) {
+    each(input, function(value) {
+      if (_.isArray(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
+  };
             		           
                               
                            
                                
               
Return a completely flattened version of an array.
             		                            
  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, []);
+  };
             		           
                               
                            
                                
               
Return a version of the array that does not contain the specified value(s).
             		                            
  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
             		           
                               
                            
                                
               
Produce a duplicate-free version of the array. If the array has already
+been sorted, you have the option of using a faster algorithm.
+Aliased as unique.
             		                            
  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
+      }
+    });
+    return results;
+  };
             		           
                               
                            
                                
               
Produce an array that contains the union: each distinct element from all of
+the passed-in arrays.
             		                            
  _.union = function() {
+    return _.uniq(concat.apply(ArrayProto, arguments));
+  };
             		           
                               
                            
                                
               
Produce an array that contains every item shared between all the
+passed-in arrays.
             		                            
  _.intersection = function(array) {
+    var rest = slice.call(arguments, 1);
+    return _.filter(_.uniq(array), function(item) {
+      return _.every(rest, function(other) {
+        return _.indexOf(other, item) >= 0;
+      });
+    });
+  };
             		           
                               
                            
                                
               
Take the difference between one array and a number of other arrays.
+Only the elements present in just the first array will remain.
             		                            
  _.difference = function(array) {
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
+  };
             		           
                               
                            
                                
               
Zip together multiple lists into a single array -- elements that share
+an index go together.
             		                            
  _.zip = function() {
+    var args = slice.call(arguments);
+    var length = _.max(_.pluck(args, 'length'));
+    var results = new Array(length);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(args, "" + i);
+    }
+    return results;
+  };
             		           
                               
                            
                                
               
Converts lists into objects. Pass either a single array of [key, value]
+pairs, or two parallel arrays of the same length -- one of keys, and one of
+the corresponding values.
             		                            
  _.object = function(list, values) {
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
             		           
                               
                            
                                
               
If the browser doesn't supply us with indexOf (I'm looking at you, MSIE),
+we need this function. Return the position of the first occurrence of an
+item in an array, or -1 if the item is not included in the array.
+Delegates to ECMAScript 5's native indexOf if available.
+If the array is large and already in sort order, pass true
+for isSorted to use binary search.
             		                            
  _.indexOf = function(array, item, isSorted) {
+    if (array == null) return -1;
+    var i = 0, l = array.length;
+    if (isSorted) {
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
+    }
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
+    return -1;
+  };
             		           
                               
                            
                                
               
Delegates to ECMAScript 5's native lastIndexOf if available.
             		                            
  _.lastIndexOf = function(array, item, from) {
+    if (array == null) return -1;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
+    return -1;
+  };
             		           
                               
                            
                                
               
Generate an integer Array containing an arithmetic progression. A port of
+the native Python range() function. See
+the Python documentation.
             		                            
  _.range = function(start, stop, step) {
+    if (arguments.length <= 1) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = arguments[2] || 1;
+
+    var len = Math.max(Math.ceil((stop - start) / step), 0);
+    var idx = 0;
+    var range = new Array(len);
+
+    while(idx < len) {
+      range[idx++] = start;
+      start += step;
+    }
+
+    return range;
+  };
             		           
                               
                            
                                
               
Function (ahem) Functions
             		                            
             		           
                               
                            
                                
               
Reusable constructor function for prototype setting.
             		                            
  var ctor = function(){};
             		           
                               
                            
                                
               
Create a function bound to a given object (assigning this, and arguments,
+optionally). Binding with arguments is also known as curry.
+Delegates to ECMAScript 5's native Function.bind if available.
+We check for func.bind first, to fail fast when func is undefined.
             		                            
  _.bind = function bind(func, context) {
+    var bound, args;
+    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+    if (!_.isFunction(func)) throw new TypeError;
+    args = slice.call(arguments, 2);
+    return bound = function() {
+      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+      ctor.prototype = func.prototype;
+      var self = new ctor;
+      var result = func.apply(self, args.concat(slice.call(arguments)));
+      if (Object(result) === result) return result;
+      return self;
+    };
+  };
             		           
                               
                            
                                
               
Bind all of an object's methods to that object. Useful for ensuring that
+all callbacks defined on an object belong to it.
             		                            
  _.bindAll = function(obj) {
+    var funcs = slice.call(arguments, 1);
+    if (funcs.length == 0) funcs = _.functions(obj);
+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+    return obj;
+  };
             		           
                               
                            
                                
               
Memoize an expensive function by storing its results.
             		                            
  _.memoize = function(func, hasher) {
+    var memo = {};
+    hasher || (hasher = _.identity);
+    return function() {
+      var key = hasher.apply(this, arguments);
+      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+    };
+  };
             		           
                               
                            
                                
               
Delays a function for the given number of milliseconds, and then calls
+it with the arguments supplied.
             		                            
  _.delay = function(func, wait) {
+    var args = slice.call(arguments, 2);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
+  };
             		           
                               
                            
                                
               
Defers a function, scheduling it to run after the current call stack has
+cleared.
             		                            
  _.defer = function(func) {
+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+  };
             		           
                               
                            
                                
               
Returns a function, that, when invoked, will only be triggered at most once
+during a given window of time.
             		                            
  _.throttle = function(func, wait) {
+    var context, args, timeout, throttling, more, result;
+    var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
+    return function() {
+      context = this; args = arguments;
+      var later = function() {
+        timeout = null;
+        if (more) {
+          result = func.apply(context, args);
+        }
+        whenDone();
+      };
+      if (!timeout) timeout = setTimeout(later, wait);
+      if (throttling) {
+        more = true;
+      } else {
+        throttling = true;
+        result = func.apply(context, args);
+      }
+      whenDone();
+      return result;
+    };
+  };
             		           
                               
                            
                                
               
Returns a function, that, as long as it continues to be invoked, will not
+be triggered. The function will be called after it stops being called for
+N milliseconds. If immediate is passed, trigger the function on the
+leading edge, instead of the trailing.
             		                            
  _.debounce = function(func, wait, immediate) {
+    var timeout, result;
+    return function() {
+      var context = this, args = arguments;
+      var later = function() {
+        timeout = null;
+        if (!immediate) result = func.apply(context, args);
+      };
+      var callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
+    };
+  };
             		           
                               
                            
                                
               
Returns a function that will be executed at most one time, no matter how
+often you call it. Useful for lazy initialization.
             		                            
  _.once = function(func) {
+    var ran = false, memo;
+    return function() {
+      if (ran) return memo;
+      ran = true;
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
+    };
+  };
             		           
                               
                            
                                
               
Returns the first function passed as an argument to the second,
+allowing you to adjust arguments, run code before and after, and
+conditionally execute the original function.
             		                            
  _.wrap = function(func, wrapper) {
+    return function() {
+      var args = [func];
+      push.apply(args, arguments);
+      return wrapper.apply(this, args);
+    };
+  };
             		           
                               
                            
                                
               
Returns a function that is the composition of a list of functions, each
+consuming the return value of the function that follows.
             		                            
  _.compose = function() {
+    var funcs = arguments;
+    return function() {
+      var args = arguments;
+      for (var i = funcs.length - 1; i >= 0; i--) {
+        args = [funcs[i].apply(this, args)];
+      }
+      return args[0];
+    };
+  };
             		           
                               
                            
                                
               
Returns a function that will only be executed after being called N times.
             		                            
  _.after = function(times, func) {
+    if (times <= 0) return func();
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
             		           
                               
                            
                                
               
Object Functions
             		                            
             		           
                               
                            
                                
               
Retrieve the names of an object's properties.
+Delegates to ECMAScript 5's native Object.keys
             		                            
  _.keys = nativeKeys || function(obj) {
+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
+    var keys = [];
+    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+    return keys;
+  };
             		           
                               
                            
                                
               
Retrieve the values of an object's properties.
             		                            
  _.values = function(obj) {
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
             		           
                               
                            
                                
               
Convert an object into a list of [key, value] pairs.
             		                            
  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
             		           
                               
                            
                                
               
Invert the keys and values of an object. The values must be serializable.
             		                            
  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
+  };
             		           
                               
                            
                                
               
Return a sorted list of the function names available on the object.
+Aliased as methods
             		                            
  _.functions = _.methods = function(obj) {
+    var names = [];
+    for (var key in obj) {
+      if (_.isFunction(obj[key])) names.push(key);
+    }
+    return names.sort();
+  };
             		           
                               
                            
                                
               
Extend a given object with all the properties in passed-in object(s).
             		                            
  _.extend = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      for (var prop in source) {
+        obj[prop] = source[prop];
+      }
+    });
+    return obj;
+  };
             		           
                               
                            
                                
               
Return a copy of the object only containing the whitelisted properties.
             		                            
  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
             		           
                               
                            
                                
               
Return a copy of the object without the blacklisted properties.
             		                            
  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
             		           
                               
                            
                                
               
Fill in a given object with default properties.
             		                            
  _.defaults = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      for (var prop in source) {
+        if (obj[prop] == null) obj[prop] = source[prop];
+      }
+    });
+    return obj;
+  };
             		           
                               
                            
                                
               
Create a (shallow-cloned) duplicate of an object.
             		                            
  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
             		           
                               
                            
                                
               
Invokes interceptor with the obj, and then returns obj.
+The primary purpose of this method is to "tap into" a method chain, in
+order to perform operations on intermediate results within the chain.
             		                            
  _.tap = function(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  };
             		           
                               
                            
                                
               
Internal recursive comparison function for isEqual.
             		                            
  var eq = function(a, b, aStack, bStack) {
             		           
                               
                            
                                
               
Identical objects are equal. 0 === -0, but they aren't identical.
+See the Harmony egal proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
             		                            
    if (a === b) return a !== 0 || 1 / a == 1 / b;
             		           
                               
                            
                                
               
A strict comparison is necessary because null == undefined.
             		                            
    if (a == null || b == null) return a === b;
             		           
                               
                            
                                
               
Unwrap any wrapped objects.
             		                            
    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
             		           
                               
                            
                                
               
Compare [[Class]] names.
             		                            
    var className = toString.call(a);
+    if (className != toString.call(b)) return false;
+    switch (className) {
             		           
                               
                            
                                
               
Strings, numbers, dates, and booleans are compared by value.
             		                            
      case '[object String]':
             		           
                               
                            
                                
               
Primitives and their corresponding object wrappers are equivalent; thus, "5" is
+equivalent to new String("5").
             		                            
        return a == String(b);
+      case '[object Number]':
             		           
                               
                            
                                
               
NaNs are equivalent, but non-reflexive. An egal comparison is performed for
+other numeric values.
             		                            
        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+      case '[object Date]':
+      case '[object Boolean]':
             		           
                               
                            
                                
               
Coerce dates and booleans to numeric primitive values. Dates are compared by their
+millisecond representations. Note that invalid dates with millisecond representations
+of NaN are not equivalent.
             		                            
        return +a == +b;
             		           
                               
                            
                                
               
RegExps are compared by their source patterns and flags.
             		                            
      case '[object RegExp]':
+        return a.source == b.source &&
+               a.global == b.global &&
+               a.multiline == b.multiline &&
+               a.ignoreCase == b.ignoreCase;
+    }
+    if (typeof a != 'object' || typeof b != 'object') return false;
             		           
                               
                            
                                
               
Assume equality for cyclic structures. The algorithm for detecting cyclic
+structures is adapted from ES 5.1 section 15.12.3, abstract operation JO.
             		                            
    var length = aStack.length;
+    while (length--) {
             		           
                               
                            
                                
               
Linear search. Performance is inversely proportional to the number of
+unique nested structures.
             		                            
      if (aStack[length] == a) return bStack[length] == b;
+    }
             		           
                               
                            
                                
               
Add the first object to the stack of traversed objects.
             		                            
    aStack.push(a);
+    bStack.push(b);
+    var size = 0, result = true;
             		           
                               
                            
                                
               
Recursively compare objects and arrays.
             		                            
    if (className == '[object Array]') {
             		           
                               
                            
                                
               
Compare array lengths to determine if a deep comparison is necessary.
             		                            
      size = a.length;
+      result = size == b.length;
+      if (result) {
             		           
                               
                            
                                
               
Deep compare the contents, ignoring non-numeric properties.
             		                            
        while (size--) {
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+        }
+      }
+    } else {
             		           
                               
                            
                                
               
Objects with different constructors are not equivalent, but Objects
+from different frames are.
             		                            
      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+        return false;
+      }
             		           
                               
                            
                                
               
Deep compare objects.
             		                            
      for (var key in a) {
+        if (_.has(a, key)) {
             		           
                               
                            
                                
               
Count the expected number of properties.
             		                            
          size++;
             		           
                               
                            
                                
               
Deep compare each member.
             		                            
          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+        }
+      }
             		           
                               
                            
                                
               
Ensure that both objects contain the same number of properties.
             		                            
      if (result) {
+        for (key in b) {
+          if (_.has(b, key) && !(size--)) break;
+        }
+        result = !size;
+      }
+    }
             		           
                               
                            
                                
               
Remove the first object from the stack of traversed objects.
             		                            
    aStack.pop();
+    bStack.pop();
+    return result;
+  };
             		           
                               
                            
                                
               
Perform a deep comparison to check if two objects are equal.
             		                            
  _.isEqual = function(a, b) {
+    return eq(a, b, [], []);
+  };
             		           
                               
                            
                                
               
Is a given array, string, or object empty?
+An "empty" object has no enumerable own-properties.
             		                            
  _.isEmpty = function(obj) {
+    if (obj == null) return true;
+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+    for (var key in obj) if (_.has(obj, key)) return false;
+    return true;
+  };
             		           
                               
                            
                                
               
Is a given value a DOM element?
             		                            
  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
             		           
                               
                            
                                
               
Is a given value an array?
+Delegates to ECMA5's native Array.isArray
             		                            
  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) == '[object Array]';
+  };
             		           
                               
                            
                                
               
Is a given variable an object?
             		                            
  _.isObject = function(obj) {
+    return obj === Object(obj);
+  };
             		           
                               
                            
                                
               
Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
             		                            
  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
             		           
                               
                            
                                
               
Define a fallback version of the method in browsers (ahem, IE), where
+there isn't any inspectable "Arguments" type.
             		                            
  if (!_.isArguments(arguments)) {
+    _.isArguments = function(obj) {
+      return !!(obj && _.has(obj, 'callee'));
+    };
+  }
             		           
                               
                            
                                
               
Optimize isFunction if appropriate.
             		                            
  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
             		           
                               
                            
                                
               
Is a given object a finite number?
             		                            
  _.isFinite = function(obj) {
+    return _.isNumber(obj) && isFinite(obj);
+  };
             		           
                               
                            
                                
               
Is the given value NaN? (NaN is the only number which does not equal itself).
             		                            
  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj != +obj;
+  };
             		           
                               
                            
                                
               
Is a given value a boolean?
             		                            
  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+  };
             		           
                               
                            
                                
               
Is a given value equal to null?
             		                            
  _.isNull = function(obj) {
+    return obj === null;
+  };
             		           
                               
                            
                                
               
Is a given variable undefined?
             		                            
  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
             		           
                               
                            
                                
               
Shortcut function for checking if an object has a given property directly
+on itself (in other words, not on a prototype).
             		                            
  _.has = function(obj, key) {
+    return hasOwnProperty.call(obj, key);
+  };
             		           
                               
                            
                                
               
Utility Functions
             		                            
             		           
                               
                            
                                
               
Run Underscore.js in noConflict mode, returning the _ variable to its
+previous owner. Returns a reference to the Underscore object.
             		                            
  _.noConflict = function() {
+    root._ = previousUnderscore;
+    return this;
+  };
             		           
                               
                            
                                
               
Keep the identity function around for default iterators.
             		                            
  _.identity = function(value) {
+    return value;
+  };
             		           
                               
                            
                                
               
Run a function n times.
             		                            
  _.times = function(n, iterator, context) {
+    for (var i = 0; i < n; i++) iterator.call(context, i);
+  };
             		           
                               
                            
                                
               
Return a random integer between min and max (inclusive).
             		                            
  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + (0 | Math.random() * (max - min + 1));
+  };
             		           
                               
                            
                                
               
List of HTML entities for escaping.
             		                            
  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
             		           
                               
                            
                                
               
Regexes containing the keys and values listed immediately above.
             		                            
  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
             		           
                               
                            
                                
               
Functions for escaping and unescaping strings to/from HTML interpolation.
             		                            
  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
             		           
                               
                            
                                
               
If the value of the named property is a function then invoke it;
+otherwise, return it.
             		                            
  _.result = function(object, property) {
+    if (object == null) return null;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
             		           
                               
                            
                                
               
Add your own custom functions to the Underscore object.
             		                            
  _.mixin = function(obj) {
+    each(_.functions(obj), function(name){
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
+    });
+  };
             		           
                               
                            
                                
               
Generate a unique integer id (unique within the entire client session).
+Useful for temporary DOM ids.
             		                            
  var idCounter = 0;
+  _.uniqueId = function(prefix) {
+    var id = idCounter++;
+    return prefix ? prefix + id : id;
+  };
             		           
                               
                            
                                
               
By default, Underscore uses ERB-style template delimiters, change the
+following template settings to use alternative delimiters.
             		                            
  _.templateSettings = {
+    evaluate    : /<%([\s\S]+?)%>/g,
+    interpolate : /<%=([\s\S]+?)%>/g,
+    escape      : /<%-([\s\S]+?)%>/g
+  };
             		           
                               
                            
                                
               
When customizing templateSettings, if you don't want to define an
+interpolation, evaluation or escaping regex, we need one that is
+guaranteed not to match.
             		                            
  var noMatch = /(.)^/;
             		           
                               
                            
                                
               
Certain characters need to be escaped so that they can be put into a
+string literal.
             		                            
  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
             		           
                               
                            
                                
               
JavaScript micro-templating, similar to John Resig's implementation.
+Underscore templating handles arbitrary delimiters, preserves whitespace,
+and correctly escapes quotes within interpolated code.
             		                            
  _.template = function(text, data, settings) {
+    settings = _.defaults({}, settings, _.templateSettings);
             		           
                               
                            
                                
               
Combine delimiters into one regular expression via alternation.
             		                            
    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
             		           
                               
                            
                                
               
Compile the template source, escaping string literals appropriately.
             		                            
    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+      source +=
+        escape ? "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'" :
+        interpolate ? "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'" :
+        evaluate ? "';\n" + evaluate + "\n__p+='" : '';
+      index = offset + match.length;
+    });
+    source += "';\n";
             		           
                               
                            
                                
               
If a variable is not specified, place data values in local scope.
             		                            
    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      var render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
             		           
                               
                            
                                
               
Provide the compiled function source as a convenience for precompilation.
             		                            
    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
+  };
             		           
                               
                            
                                
               
Add a "chain" function, which will delegate to the wrapper.
             		                            
  _.chain = function(obj) {
+    return _(obj).chain();
+  };
             		           
                               
                            
                                
               
OOP

+
+
If Underscore is called as a function, it returns a wrapped object that
+can be used OO-style. This wrapper holds altered versions of all the
+underscore functions. Wrapped objects may be chained.
             		                            
             		           
                               
                            
                                
               
Helper function to continue chaining intermediate results.
             		                            
  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
+  };
             		           
                               
                            
                                
               
Add all of the Underscore functions to the wrapper object.
             		                            
  _.mixin(_);
             		           
                               
                            
                                
               
Add all mutator Array functions to the wrapper.
             		                            
  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
+    };
+  });
             		           
                               
                            
                                
               
Add all accessor Array functions to the wrapper.
             		                            
  each(['concat', 'join', 'slice'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
+    };
+  });
+
+  _.extend(_.prototype, {
             		           
                               
                            
                                
               
Start chaining a wrapped Underscore object.
             		                            
    chain: function() {
+      this._chain = true;
+      return this;
+    },
             		           
                               
                            
                                
               
Extracts the result from a wrapped and chained object.
             		                            
    value: function() {
+      return this._wrapped;
+    }
+
+  });
+
+}).call(this);
+
+
             		           
                     
   
   
\ No newline at end of file
diff --git a/underscore/favicon.ico b/underscore/favicon.ico
new file mode 100644
index 0000000..0304968
Binary files /dev/null and b/underscore/favicon.ico differ
diff --git a/underscore/index.html b/underscore/index.html
new file mode 100644
index 0000000..71b1f5a
--- /dev/null
+++ b/underscore/index.html
@@ -0,0 +1,2367 @@
+
+
+
+  
+  
+  
+  
+  
+  Underscore.js
+  
+
+
+
+  
+
+  

+
+    

+      
+    

+
+    

+      Underscore is a
+      utility-belt library for JavaScript that provides a lot of the
+      functional programming support that you would expect in
+      Prototype.js
+      (or Ruby),
+      but without extending any of the built-in JavaScript objects. It's the
+      tie to go along with jQuery's tux,
+      and Backbone.js's suspenders.
+    

+
+    

+      Underscore provides 80-odd functions that support both the usual
+      functional suspects: map, select, invoke —
+      as well as more specialized helpers: function binding, javascript
+      templating, deep equality testing, and so on. It delegates to built-in
+      functions, if present, so modern browsers will use the
+      native implementations of forEach, map, reduce,
+      filter, every, some and indexOf.
+    

+
+    

+      A complete Test & Benchmark Suite
+      is included for your perusal.
+    

+
+    

+      You may also read through the annotated source code.
+    

+
+    

+      The project is
+      hosted on GitHub.
+      You can report bugs and discuss features on the
+      issues page,
+      on Freenode in the #documentcloud channel,
+      or send tweets to @documentcloud.
+    

+
+    

+      Underscore is an open-source component of DocumentCloud.
+    

+
+    
Downloads (Right-click, and use "Save As")

+
+    
+      
+        
+        
+      
+      
+        
+        
+      
+      
+        
+      
+      
+        
+        
+      
+    
Development Version (1.4.2)40kb, Uncompressed with Plentiful Comments
Production Version (1.4.2)4kb, Minified and Gzipped
Edge VersionUnreleased, current master, use at your own risk

+
+    

+
+      
Collection Functions (Arrays or Objects)

+
+      

+        each_.each(list, iterator, [context])
+        Alias: forEach
+        

+        Iterates over a list of elements, yielding each in turn to an iterator
+        function. The iterator is bound to the context object, if one is
+        passed. Each invocation of iterator is called with three arguments:
+        (element, index, list). If list is a JavaScript object, iterator's
+        arguments will be (value, key, list). Delegates to the native
+        forEach function if it exists.
+      

+      
+_.each([1, 2, 3], function(num){ alert(num); });
+=> alerts each number in turn...
+_.each({one : 1, two : 2, three : 3}, function(num, key){ alert(num); });
+=> alerts each number in turn...

+
+      

+        map_.map(list, iterator, [context])
+        Alias: collect
+        

+        Produces a new array of values by mapping each value in list
+        through a transformation function (iterator). If the native map method
+        exists, it will be used instead. If list is a JavaScript object,
+        iterator's arguments will be (value, key, list).
+      

+      
+_.map([1, 2, 3], function(num){ return num * 3; });
+=> [3, 6, 9]
+_.map({one : 1, two : 2, three : 3}, function(num, key){ return num * 3; });
+=> [3, 6, 9]

+
+      

+        reduce_.reduce(list, iterator, memo, [context])
+        Aliases: inject, foldl
+        

+        Also known as inject and foldl, reduce boils down a
+        list of values into a single value. Memo is the initial state
+        of the reduction, and each successive step of it should be returned by
+        iterator. The iterator is passed four arguments: the memo,
+        then the value and index (or key) of the iteration,
+        and finally a reference to the entire list.
+      

+      
+var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);
+=> 6
+

+
+      

+        reduceRight_.reduceRight(list, iterator, memo, [context])
+        Alias: foldr
+        

+        The right-associative version of reduce. Delegates to the
+        JavaScript 1.8 version of reduceRight, if it exists. Foldr
+        is not as useful in JavaScript as it would be in a language with lazy
+        evaluation.
+      

+      
+var list = [[0, 1], [2, 3], [4, 5]];
+var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+=> [4, 5, 2, 3, 0, 1]
+

+
+      

+        find_.find(list, iterator, [context])
+        Alias: detect
+        

+        Looks through each value in the list, returning the first one that
+        passes a truth test (iterator). The function returns as
+        soon as it finds an acceptable element, and doesn't traverse the
+        entire list.
+      

+      
+var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> 2
+

+
+      

+        filter_.filter(list, iterator, [context])
+        Alias: select
+        

+        Looks through each value in the list, returning an array of all
+        the values that pass a truth test (iterator). Delegates to the
+        native filter method, if it exists.
+      

+      
+var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> [2, 4, 6]
+

+
+      

+        where_.where(list, properties)
+        

+        Looks through each value in the list, returning an array of all
+        the values that contain all of the key-value pairs listed in properties.
+      

+      
+_.where(listOfPlays, {author: "Shakespeare", year: 1611});
+=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},
+    {title: "The Tempest", author: "Shakespeare", year: 1611}]
+

+
+      

+        reject_.reject(list, iterator, [context])
+        

+        Returns the values in list without the elements that the truth
+        test (iterator) passes. The opposite of filter.
+      

+      
+var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> [1, 3, 5]
+

+
+      

+        all_.all(list, iterator, [context])
+        Alias: every
+        

+        Returns true if all of the values in the list pass the iterator
+        truth test. Delegates to the native method every, if present.
+      

+      
+_.all([true, 1, null, 'yes'], _.identity);
+=> false
+

+
+      

+        any_.any(list, [iterator], [context])
+        Alias: some
+        

+        Returns true if any of the values in the list pass the
+        iterator truth test. Short-circuits and stops traversing the list
+        if a true element is found. Delegates to the native method some,
+        if present.
+      

+      
+_.any([null, 0, 'yes', false]);
+=> true
+

+
+      

+        contains_.contains(list, value)
+        Alias: include
+        

+        Returns true if the value is present in the list.
+        Uses indexOf internally, if list is an Array.
+      

+      
+_.contains([1, 2, 3], 3);
+=> true
+

+
+      

+        invoke_.invoke(list, methodName, [*arguments])
+        

+        Calls the method named by methodName on each value in the list.
+        Any extra arguments passed to invoke will be forwarded on to the
+        method invocation.
+      

+      
+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+=> [[1, 5, 7], [1, 2, 3]]
+

+
+      

+        pluck_.pluck(list, propertyName)
+        

+        A convenient version of what is perhaps the most common use-case for
+        map: extracting a list of property values.
+      

+      
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.pluck(stooges, 'name');
+=> ["moe", "larry", "curly"]
+

+
+      

+        max_.max(list, [iterator], [context])
+        

+        Returns the maximum value in list. If iterator is passed,
+        it will be used on each value to generate the criterion by which the
+        value is ranked.
+      

+      
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.max(stooges, function(stooge){ return stooge.age; });
+=> {name : 'curly', age : 60};
+

+
+      

+        min_.min(list, [iterator], [context])
+        

+        Returns the minimum value in list. If iterator is passed,
+        it will be used on each value to generate the criterion by which the
+        value is ranked.
+      

+      
+var numbers = [10, 5, 100, 2, 1000];
+_.min(numbers);
+=> 2
+

+
+      

+        sortBy_.sortBy(list, iterator, [context])
+        

+        Returns a sorted copy of list, ranked in ascending order by the
+        results of running each value through iterator. Iterator may
+        also be the string name of the property to sort by (eg. length).
+      

+      
+_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
+=> [5, 4, 6, 3, 1, 2]
+

+
+      

+        groupBy_.groupBy(list, iterator)
+        

+        Splits a collection into sets, grouped by the result of running each
+        value through iterator. If iterator is a string instead of
+        a function, groups by the property named by iterator on each of
+        the values.
+      

+      
+_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
+=> {1: [1.3], 2: [2.1, 2.4]}
+
+_.groupBy(['one', 'two', 'three'], 'length');
+=> {3: ["one", "two"], 5: ["three"]}
+

+
+      

+        countBy_.countBy(list, iterator)
+        

+        Sorts a list into groups and returns a count for the number of objects
+        in each group.
+        Similar to groupBy, but instead of returning a list of values, 
+        returns a count for the number of values in that group.
+      

+      
+_.countBy([1, 2, 3, 4, 5], function(num) { 
+  return num % 2 == 0 ? 'even' : 'odd'; 
+});
+=> {odd: 3, even: 2}
+

+
+      

+        shuffle_.shuffle(list)
+        

+        Returns a shuffled copy of the list, using a version of the
+        Fisher-Yates shuffle.
+      

+      
+_.shuffle([1, 2, 3, 4, 5, 6]);
+=> [4, 1, 6, 3, 5, 2]
+

+
+      

+        toArray_.toArray(list)
+        

+        Converts the list (anything that can be iterated over), into a
+        real Array. Useful for transmuting the arguments object.
+      

+      
+(function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+=> [2, 3, 4]
+

+
+      

+        size_.size(list)
+        

+        Return the number of values in the list.
+      

+      
+_.size({one : 1, two : 2, three : 3});
+=> 3
+

+
+      
Array Functions

+
+      

+        
+          Note: All array functions will also work on the arguments object.
+          However, Underscore functions are not designed to work on "sparse" arrays.
+        
+      

+
+      

+        first_.first(array, [n])
+        Alias: head, take
+        

+        Returns the first element of an array. Passing n will
+        return the first n elements of the array.
+      

+      
+_.first([5, 4, 3, 2, 1]);
+=> 5
+

+
+      

+        initial_.initial(array, [n])
+        

+        Returns everything but the last entry of the array. Especially useful on
+        the arguments object. Pass n to exclude the last n elements
+        from the result.
+      

+      
+_.initial([5, 4, 3, 2, 1]);
+=> [5, 4, 3, 2]
+

+
+      

+        last_.last(array, [n])
+        

+        Returns the last element of an array. Passing n will return
+        the last n elements of the array.
+      

+      
+_.last([5, 4, 3, 2, 1]);
+=> 1
+

+
+      

+        rest_.rest(array, [index])
+        Alias: tail, drop
+        

+        Returns the rest of the elements in an array. Pass an index
+        to return the values of the array from that index onward.
+      

+      
+_.rest([5, 4, 3, 2, 1]);
+=> [4, 3, 2, 1]
+

+
+      

+        compact_.compact(array)
+        

+        Returns a copy of the array with all falsy values removed.
+        In JavaScript, false, null, 0, "",
+        undefined and NaN are all falsy.
+      

+      
+_.compact([0, 1, false, 2, '', 3]);
+=> [1, 2, 3]
+

+
+      

+        flatten_.flatten(array, [shallow])
+        

+        Flattens a nested array (the nesting can be to any depth). If you
+        pass shallow, the array will only be flattened a single level.
+      

+      
+_.flatten([1, [2], [3, [[4]]]]);
+=> [1, 2, 3, 4];
+
+_.flatten([1, [2], [3, [[4]]]], true);
+=> [1, 2, 3, [[4]]];
+

+
+      

+        without_.without(array, [*values])
+        

+        Returns a copy of the array with all instances of the values
+        removed.
+      

+      
+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+=> [2, 3, 4]
+

+
+      

+        union_.union(*arrays)
+        

+        Computes the union of the passed-in arrays: the list of unique items,
+        in order, that are present in one or more of the arrays.
+      

+      
+_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+=> [1, 2, 3, 101, 10]
+

+
+      

+        intersection_.intersection(*arrays)
+        

+        Computes the list of values that are the intersection of all the arrays.
+        Each value in the result is present in each of the arrays.
+      

+      
+_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+=> [1, 2]
+

+
+      

+        difference_.difference(array, *others)
+        

+        Similar to without, but returns the values from array that
+        are not present in the other arrays.
+      

+      
+_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+=> [1, 3, 4]
+

+
+      

+        uniq_.uniq(array, [isSorted], [iterator])
+        Alias: unique
+        

+        Produces a duplicate-free version of the array, using === to test
+        object equality. If you know in advance that the array is sorted,
+        passing true for isSorted will run a much faster algorithm.
+        If you want to compute unique items based on a transformation, pass an
+        iterator function.
+      

+      
+_.uniq([1, 2, 1, 3, 1, 4]);
+=> [1, 2, 3, 4]
+

+
+      

+        zip_.zip(*arrays)
+        

+        Merges together the values of each of the arrays with the
+        values at the corresponding position. Useful when you have separate
+        data sources that are coordinated through matching array indexes.
+        If you're working with a matrix of nested arrays, zip.apply
+        can transpose the matrix in a similar fashion.
+      

+      
+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
+=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
+

+
+      

+        object_.object(list, [values])
+        

+        Converts arrays into objects. Pass either a single list of 
+        [key, value] pairs, or a list of keys, and a list of values.
+      

+      
+_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+=> {moe: 30, larry: 40, curly: 50}
+
+_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
+=> {moe: 30, larry: 40, curly: 50}
+

+
+      

+        indexOf_.indexOf(array, value, [isSorted])
+        

+        Returns the index at which value can be found in the array,
+        or -1 if value is not present in the array. Uses the native
+        indexOf function unless it's missing. If you're working with a
+        large array, and you know that the array is already sorted, pass true
+        for isSorted to use a faster binary search ... or, pass a number as 
+        the third argument in order to look for the first matching value in the 
+        array after the given index.
+      

+      
+_.indexOf([1, 2, 3], 2);
+=> 1
+

+
+      

+        lastIndexOf_.lastIndexOf(array, value, [fromIndex])
+        

+        Returns the index of the last occurrence of value in the array,
+        or -1 if value is not present. Uses the native lastIndexOf
+        function if possible. Pass fromIndex to start your search at a 
+        given index.
+      

+      
+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+=> 4
+

+
+      

+        sortedIndex_.sortedIndex(list, value, [iterator])
+        

+        Uses a binary search to determine the index at which the value
+        should be inserted into the list in order to maintain the list's
+        sorted order. If an iterator is passed, it will be used to compute
+        the sort ranking of each value, including the value you pass.
+      

+      
+_.sortedIndex([10, 20, 30, 40, 50], 35);
+=> 3
+

+
+      

+        range_.range([start], stop, [step])
+        

+        A function to create flexibly-numbered lists of integers, handy for
+        each and map loops. start, if omitted, defaults
+        to 0; step defaults to 1. Returns a list of integers
+        from start to stop, incremented (or decremented) by step,
+        exclusive.
+      

+      
+_.range(10);
+=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+_.range(1, 11);
+=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+_.range(0, 30, 5);
+=> [0, 5, 10, 15, 20, 25]
+_.range(0, -10, -1);
+=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+_.range(0);
+=> []
+

+
+      
Function (uh, ahem) Functions

+
+      

+        bind_.bind(function, object, [*arguments])
+        

+        Bind a function to an object, meaning that whenever
+        the function is called, the value of this will be the object.
+        Optionally, bind arguments to the function to pre-fill them,
+        also known as partial application.
+      

+      
+var func = function(greeting){ return greeting + ': ' + this.name };
+func = _.bind(func, {name : 'moe'}, 'hi');
+func();
+=> 'hi: moe'
+

+
+      

+        bindAll_.bindAll(object, [*methodNames])
+        

+        Binds a number of methods on the object, specified by
+        methodNames, to be run in the context of that object whenever they
+        are invoked. Very handy for binding functions that are going to be used
+        as event handlers, which would otherwise be invoked with a fairly useless
+        this. If no methodNames are provided, all of the object's
+        function properties will be bound to it.
+      

+      
+var buttonView = {
+  label   : 'underscore',
+  onClick : function(){ alert('clicked: ' + this.label); },
+  onHover : function(){ console.log('hovering: ' + this.label); }
+};
+_.bindAll(buttonView);
+jQuery('#underscore_button').bind('click', buttonView.onClick);
+=> When the button is clicked, this.label will have the correct value...
+

+
+      

+        memoize_.memoize(function, [hashFunction])
+        

+        Memoizes a given function by caching the computed result. Useful
+        for speeding up slow-running computations. If passed an optional
+        hashFunction, it will be used to compute the hash key for storing
+        the result, based on the arguments to the original function. The default
+        hashFunction just uses the first argument to the memoized function
+        as the key.
+      

+      
+var fibonacci = _.memoize(function(n) {
+  return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+});
+

+
+      

+        delay_.delay(function, wait, [*arguments])
+        

+        Much like setTimeout, invokes function after wait
+        milliseconds. If you pass the optional arguments, they will be
+        forwarded on to the function when it is invoked.
+      

+      
+var log = _.bind(console.log, console);
+_.delay(log, 1000, 'logged later');
+=> 'logged later' // Appears after one second.
+

+
+      

+        defer_.defer(function, [*arguments])
+        

+        Defers invoking the function until the current call stack has cleared,
+        similar to using setTimeout with a delay of 0. Useful for performing
+        expensive computations or HTML rendering in chunks without blocking the UI thread
+        from updating. If you pass the optional arguments, they will be
+        forwarded on to the function when it is invoked.
+      

+      
+_.defer(function(){ alert('deferred'); });
+// Returns from the function before the alert runs.
+

+
+      

+        throttle_.throttle(function, wait)
+        

+        Creates and returns a new, throttled version of the passed function,
+        that, when invoked repeatedly, will only actually call the original function
+        at most once per every wait
+        milliseconds. Useful for rate-limiting events that occur faster than you
+        can keep up with.
+      

+      
+var throttled = _.throttle(updatePosition, 100);
+$(window).scroll(throttled);
+

+
+      

+        debounce_.debounce(function, wait, [immediate])
+        

+        Creates and returns a new debounced version of the passed function that
+        will postpone its execution until after
+        wait milliseconds have elapsed since the last time it
+        was invoked. Useful for implementing behavior that should only happen
+        after the input has stopped arriving. For example: rendering a
+        preview of a Markdown comment, recalculating a layout after the window
+        has stopped being resized, and so on.
+      

+
+      

+        Pass true for the immediate parameter to cause
+        debounce to trigger the function on the leading instead of the
+        trailing edge of the wait interval. Useful in circumstances like
+        preventing accidental double-clicks on a "submit" button from firing a
+        second time.
+      

+
+      
+var lazyLayout = _.debounce(calculateLayout, 300);
+$(window).resize(lazyLayout);
+

+
+      

+        once_.once(function)
+        

+        Creates a version of the function that can only be called one time.
+        Repeated calls to the modified function will have no effect, returning
+        the value from the original call. Useful for initialization functions,
+        instead of having to set a boolean flag and then check it later.
+      

+      
+var initialize = _.once(createApplication);
+initialize();
+initialize();
+// Application is only created once.
+

+
+      

+        after_.after(count, function)
+        

+        Creates a version of the function that will only be run after first
+        being called count times. Useful for grouping asynchronous responses,
+        where you want to be sure that all the async calls have finished, before
+        proceeding.
+      

+      
+var renderNotes = _.after(notes.length, render);
+_.each(notes, function(note) {
+  note.asyncSave({success: renderNotes});
+});
+// renderNotes is run once, after all notes have saved.
+

+
+      

+        wrap_.wrap(function, wrapper)
+        

+        Wraps the first function inside of the wrapper function,
+        passing it as the first argument. This allows the wrapper to
+        execute code before and after the function runs, adjust the arguments,
+        and execute it conditionally.
+      

+      
+var hello = function(name) { return "hello: " + name; };
+hello = _.wrap(hello, function(func) {
+  return "before, " + func("moe") + ", after";
+});
+hello();
+=> 'before, hello: moe, after'
+

+
+      

+        compose_.compose(*functions)
+        

+        Returns the composition of a list of functions, where each function
+        consumes the return value of the function that follows. In math terms,
+        composing the functions f(), g(), and h() produces
+        f(g(h())).
+      

+      
+var greet    = function(name){ return "hi: " + name; };
+var exclaim  = function(statement){ return statement + "!"; };
+var welcome = _.compose(exclaim, greet);
+welcome('moe');
+=> 'hi: moe!'
+

+
+      
Object Functions

+
+      

+        keys_.keys(object)
+        

+        Retrieve all the names of the object's properties.
+      

+      
+_.keys({one : 1, two : 2, three : 3});
+=> ["one", "two", "three"]
+

+
+      

+        values_.values(object)
+        

+        Return all of the values of the object's properties.
+      

+      
+_.values({one : 1, two : 2, three : 3});
+=> [1, 2, 3]
+

+
+      

+        pairs_.pairs(object)
+        

+        Convert an object into a list of [key, value] pairs.
+      

+      
+_.pairs({one: 1, two: 2, three: 3});
+=> [["one", 1], ["two", 2], ["three", 3]]
+

+
+      

+        invert_.invert(object)
+        

+        Returns a copy of the object where the keys have become the values
+        and the values the keys. For this to work, all of your object's values 
+        should be unique and string serializable.
+      

+      
+_.invert({Moe: "Moses", Larry: "Louis", Curly: "Jerome"});
+=> {Moses: "Moe", Louis: "Larry", Jerome: "Curly"};
+

+
+      

+        functions_.functions(object)
+        Alias: methods
+        

+        Returns a sorted list of the names of every method in an object —
+        that is to say, the name of every function property of the object.
+      

+      
+_.functions(_);
+=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...
+

+
+      

+        extend_.extend(destination, *sources)
+        

+        Copy all of the properties in the source objects over to the
+        destination object, and return the destination object.
+        It's in-order, so the last source will override properties of the same
+        name in previous arguments.
+      

+      
+_.extend({name : 'moe'}, {age : 50});
+=> {name : 'moe', age : 50}
+

+
+      

+        pick_.pick(object, *keys)
+        

+        Return a copy of the object, filtered to only have values for
+        the whitelisted keys (or array of valid keys).
+      

+      
+_.pick({name : 'moe', age: 50, userid : 'moe1'}, 'name', 'age');
+=> {name : 'moe', age : 50}
+

+
+      

+        omit_.omit(object, *keys)
+        

+        Return a copy of the object, filtered to omit the blacklisted
+        keys (or array of keys).
+      

+      
+_.omit({name : 'moe', age : 50, userid : 'moe1'}, 'userid');
+=> {name : 'moe', age : 50}
+

+
+      

+        defaults_.defaults(object, *defaults)
+        

+        Fill in null and undefined properties in object with values from the
+        defaults objects, and return the object. As soon as the
+        property is filled, further defaults will have no effect.
+      

+      
+var iceCream = {flavor : "chocolate"};
+_.defaults(iceCream, {flavor : "vanilla", sprinkles : "lots"});
+=> {flavor : "chocolate", sprinkles : "lots"}
+

+
+      

+        clone_.clone(object)
+        

+        Create a shallow-copied clone of the object. Any nested objects
+        or arrays will be copied by reference, not duplicated.
+      

+      
+_.clone({name : 'moe'});
+=> {name : 'moe'};
+

+
+      

+        tap_.tap(object, interceptor)
+        

+        Invokes interceptor with the object, and then returns object.
+        The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.
+      

+      
+_.chain([1,2,3,200])
+  .filter(function(num) { return num % 2 == 0; })
+  .tap(alert)
+  .map(function(num) { return num * num })
+  .value();
+=> // [2, 200] (alerted)
+=> [4, 40000]
+

+
+      

+        has_.has(object, key)
+        

+        Does the object contain the given key? Identical to
+        object.hasOwnProperty(key), but uses a safe reference to the
+        hasOwnProperty function, in case it's been
+        overridden accidentally.
+      

+      
+_.has({a: 1, b: 2, c: 3}, "b");
+=> true
+

+
+      

+        isEqual_.isEqual(object, other)
+        

+        Performs an optimized deep comparison between the two objects, to determine
+        if they should be considered equal.
+      

+      
+var moe   = {name : 'moe', luckyNumbers : [13, 27, 34]};
+var clone = {name : 'moe', luckyNumbers : [13, 27, 34]};
+moe == clone;
+=> false
+_.isEqual(moe, clone);
+=> true
+

+
+      

+        isEmpty_.isEmpty(object)
+        

+        Returns true if object contains no values.
+      

+      
+_.isEmpty([1, 2, 3]);
+=> false
+_.isEmpty({});
+=> true
+

+
+      

+        isElement_.isElement(object)
+        

+        Returns true if object is a DOM element.
+      

+      
+_.isElement(jQuery('body')[0]);
+=> true
+

+
+      

+        isArray_.isArray(object)
+        

+        Returns true if object is an Array.
+      

+      
+(function(){ return _.isArray(arguments); })();
+=> false
+_.isArray([1,2,3]);
+=> true
+

+
+      

+        isObject_.isObject(value)
+        

+        Returns true if value is an Object. Note that JavaScript
+        arrays and functions are objects, while (normal) strings and numbers are not.
+      

+      
+_.isObject({});
+=> true
+_.isObject(1);
+=> false
+

+
+      

+        isArguments_.isArguments(object)
+        

+        Returns true if object is an Arguments object.
+      

+      
+(function(){ return _.isArguments(arguments); })(1, 2, 3);
+=> true
+_.isArguments([1,2,3]);
+=> false
+

+
+      

+        isFunction_.isFunction(object)
+        

+        Returns true if object is a Function.
+      

+      
+_.isFunction(alert);
+=> true
+

+
+      

+        isString_.isString(object)
+        

+        Returns true if object is a String.
+      

+      
+_.isString("moe");
+=> true
+

+
+      

+        isNumber_.isNumber(object)
+        

+        Returns true if object is a Number (including NaN).
+      

+      
+_.isNumber(8.4 * 5);
+=> true
+

+
+      

+        isFinite_.isFinite(object)
+        

+        Returns true if object is a finite Number.
+      

+      
+_.isFinite(-101);
+=> true
+
+_.isFinite(-Infinity);
+=> false
+

+
+      

+        isBoolean_.isBoolean(object)
+        

+        Returns true if object is either true or false.
+      

+      
+_.isBoolean(null);
+=> false
+

+
+      

+        isDate_.isDate(object)
+        

+        Returns true if object is a Date.
+      

+      
+_.isDate(new Date());
+=> true
+

+
+      

+        isRegExp_.isRegExp(object)
+        

+        Returns true if object is a RegExp.
+      

+      
+_.isRegExp(/moe/);
+=> true
+

+
+      

+        isNaN_.isNaN(object)
+        

+        Returns true if object is NaN.
 Note: this is not
+        the same as the native isNaN function, which will also return
+        true if the variable is undefined.
+      

+      
+_.isNaN(NaN);
+=> true
+isNaN(undefined);
+=> true
+_.isNaN(undefined);
+=> false
+

+
+      

+        isNull_.isNull(object)
+        

+        Returns true if the value of object is null.
+      

+      
+_.isNull(null);
+=> true
+_.isNull(undefined);
+=> false
+

+
+      

+        isUndefined_.isUndefined(value)
+        

+        Returns true if value is undefined.
+      

+      
+_.isUndefined(window.missingVariable);
+=> true
+

+
+      
Utility Functions

+
+      

+        noConflict_.noConflict()
+        

+        Give control of the "_" variable back to its previous owner. Returns
+        a reference to the Underscore object.
+      

+      
+var underscore = _.noConflict();

+
+      

+        identity_.identity(value)
+        

+        Returns the same value that is used as the argument. In math:
+        f(x) = x

+        This function looks useless, but is used throughout Underscore as
+        a default iterator.
+      

+      
+var moe = {name : 'moe'};
+moe === _.identity(moe);
+=> true

+
+      

+        times_.times(n, iterator, [context])
+        

+        Invokes the given iterator function n times. Each invocation of 
+        iterator is called with an index argument.
+      

+      
+_(3).times(function(n){ genie.grantWishNumber(n); });

+
+      

+        random_.random(min, max)
+        

+        Returns a random integer between min and max, inclusive.
+        If you only pass one argument, it will return a number between 0
+        and that number.
+      

+      
+_.random(0, 100);
+=> 42

+
+      

+        mixin_.mixin(object)
+        

+        Allows you to extend Underscore with your own utility functions. Pass
+        a hash of {name: function} definitions to have your functions
+        added to the Underscore object, as well as the OOP wrapper.
+      

+      
+_.mixin({
+  capitalize : function(string) {
+    return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
+  }
+});
+_("fabio").capitalize();
+=> "Fabio"
+

+
+      

+        uniqueId_.uniqueId([prefix])
+        

+        Generate a globally-unique id for client-side models or DOM elements
+        that need one. If prefix is passed, the id will be appended to it.
+        Without prefix, returns an integer.
+      

+      
+_.uniqueId('contact_');
+=> 'contact_104'

+
+      

+        escape_.escape(string)
+        

+        Escapes a string for insertion into HTML, replacing
+        &, <, >, ", ', and / characters.
+      

+      
+_.escape('Curly, Larry & Moe');
+=> "Curly, Larry &amp; Moe"

+
+      

+        result_.result(object, property)
+        

+        If the value of the named property is a function then invoke it; otherwise, return it.
+      

+      
+var object = {cheese: 'crumpets', stuff: function(){ return 'nonsense'; }};
+_.result(object, 'cheese');
+=> "crumpets"
+_.result(object, 'stuff');
+=> "nonsense"

+
+      

+        template_.template(templateString, [data], [settings])
+        

+        Compiles JavaScript templates into functions that can be evaluated
+        for rendering. Useful for rendering complicated bits of HTML from JSON
+        data sources. Template functions can both interpolate variables, using
+        <%= … %>, as well as execute arbitrary JavaScript code, with
+        <% … %>. If you wish to interpolate a value, and have
+        it be HTML-escaped, use <%- … %> When you evaluate a template function, pass in a
+        data object that has properties corresponding to the template's free
+        variables. If you're writing a one-off, you can pass the data
+        object as the second parameter to template in order to render
+        immediately instead of returning a template function.  The settings argument
+        should be a hash containing any _.templateSettings that should be overridden.
+      

+
+      
+var compiled = _.template("hello: <%= name %>");
+compiled({name : 'moe'});
+=> "hello: moe"
+
+var list = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
+_.template(list, {people : ['moe', 'curly', 'larry']});
+=> "<li>moe</li><li>curly</li><li>larry</li>"
+
+var template = _.template("<b><%- value %></b>");
+template({value : '<script>'});
+=> "<b>&lt;script&gt;</b>"

+
+      

+        You can also use print from within JavaScript code.  This is
+        sometimes more convenient than using <%= ... %>.
+      

+
+      
+var compiled = _.template("<% print('Hello ' + epithet); %>");
+compiled({epithet: "stooge"});
+=> "Hello stooge."

+
+      

+        If ERB-style delimiters aren't your cup of tea, you can change Underscore's
+        template settings to use different symbols to set off interpolated code.
+        Define an interpolate regex to match expressions that should be
+        interpolated verbatim, an escape regex to match expressions that should
+        be inserted after being HTML escaped, and an evaluate regex to match
+        expressions that should be evaluated without insertion into the resulting
+        string. You may define or omit any combination of the three.
+        For example, to perform
+        Mustache.js
+        style templating:
+      

+
+      
+_.templateSettings = {
+  interpolate : /\{\{(.+?)\}\}/g
+};
+
+var template = _.template("Hello {{ name }}!");
+template({name : "Mustache"});
+=> "Hello Mustache!"

+
+      

+        By default, template places the values from your data in the local scope
+        via the with statement.  However, you can specify a single variable name
+        with the variable setting. This can significantly improve the speed
+        at which a template is able to render.
+      

+
+      
+_.template("Using 'with': <%= data.answer %>", {answer: 'no'}, {variable: 'data'});
+=> "Using 'with': no"

+
+      

+        Precompiling your templates can be a big help when debugging errors you can't
+        reproduce.  This is because precompiled templates can provide line numbers and
+        a stack trace, something that is not possible when compiling templates on the client.
+        The source property is available on the compiled template
+        function for easy precompilation.
+      

+
+      
<script>
+  JST.project = <%= _.template(jstText).source %>;
+</script>

+
+
+      
Chaining

+
+      

+        You can use Underscore in either an object-oriented or a functional style,
+        depending on your preference. The following two lines of code are
+        identical ways to double a list of numbers.
+      

+
+    
+_.map([1, 2, 3], function(n){ return n * 2; });
+_([1, 2, 3]).map(function(n){ return n * 2; });

+
+      

+        Calling chain will cause all future method calls to return
+        wrapped objects. When you've finished the computation, use
+        value to retrieve the final value. Here's an example of chaining
+        together a map/flatten/reduce, in order to get the word count of
+        every word in a song.
+      

+
+
+var lyrics = [
+  {line : 1, words : "I'm a lumberjack and I'm okay"},
+  {line : 2, words : "I sleep all night and I work all day"},
+  {line : 3, words : "He's a lumberjack and he's okay"},
+  {line : 4, words : "He sleeps all night and he works all day"}
+];
+
+_.chain(lyrics)
+  .map(function(line) { return line.words.split(' '); })
+  .flatten()
+  .reduce(function(counts, word) {
+    counts[word] = (counts[word] || 0) + 1;
+    return counts;
+}, {}).value();
+
+=> {lumberjack : 2, all : 4, night : 2 ... }

+
+      

+        In addition, the
+        Array prototype's methods
+        are proxied through the chained Underscore object, so you can slip a
+        reverse or a push into your chain, and continue to
+        modify the array.
+      

+
+      

+        chain_.chain(obj)
+        

+        Returns a wrapped object. Calling methods on this object will continue
+        to return wrapped objects until value is used.
+      

+      
+var stooges = [{name : 'curly', age : 25}, {name : 'moe', age : 21}, {name : 'larry', age : 23}];
+var youngest = _.chain(stooges)
+  .sortBy(function(stooge){ return stooge.age; })
+  .map(function(stooge){ return stooge.name + ' is ' + stooge.age; })
+  .first()
+  .value();
+=> "moe is 21"
+

+
+      

+        value_(obj).value()
+        

+        Extracts the value of a wrapped object.
+      

+      
+_([1, 2, 3]).value();
+=> [1, 2, 3]
+

+
+      
+
+      

+        The Underscore documentation is also available in
+        Simplified Chinese.
+      

+
+      

+        Underscore.lua,
+        a Lua port of the functions that are applicable in both languages.
+        Includes OOP-wrapping and chaining.
+        (source)
+      

+
+      

+        Underscore.m, an Objective-C port
+        of many of the Underscore.js functions, using a syntax that encourages
+        chaining.
+        (source)
+      

+
+      

+        _.m, an alternative
+        Objective-C port that tries to stick a little closer to the original
+        Underscore.js API.
+        (source)
+      

+
+      

+        Underscore.php,
+        a PHP port of the functions that are applicable in both languages.
+        Includes OOP-wrapping and chaining.
+        (source)
+      

+
+      

+        Underscore-perl,
+        a Perl port of many of the Underscore.js functions,
+        aimed at on Perl hashes and arrays.
+        (source)
+      

+
+      

+        Underscore.cfc,
+        a Coldfusion port of many of the Underscore.js functions.
+        (source)
+      

+
+      

+        Underscore.string,
+        an Underscore extension that adds functions for string-manipulation:
+        trim, startsWith, contains, capitalize,
+        reverse, sprintf, and more.
+      

+
+      

+        Ruby's Enumerable module.
+      

+
+      

+        Prototype.js, which provides
+        JavaScript with collection functions in the manner closest to Ruby's Enumerable.
+      

+
+      

+        Oliver Steele's
+        Functional JavaScript,
+        which includes comprehensive higher-order function support as well as string lambdas.
+      

+
+      

+        Michael Aufreiter's Data.js,
+        a data manipulation + persistence library for JavaScript.
+      

+
+      

+        Python's itertools.
+      

+
+      
Change Log

+      
+      

+        1.4.2 — Oct. 1, 2012  — Diff

+        
    
+          
  • 
+            For backwards compatibility, returned to pre-1.4.0 behavior when 
+            passing null to iteration functions. They now become no-ops 
+            again.
+          
    • 
+        

+      

+      
+      

+        1.4.1 — Oct. 1, 2012  — Diff

+        
    
+          
  • 
+            Fixed a 1.4.0 regression in the lastIndexOf function.
+          
    • 
+        

+      

+      
+      

+        1.4.0 — Sept. 27, 2012  — Diff

+        
    
+          
  • 
+            Added a pairs function, for turning a JavaScript object 
+            into [key, value] pairs ... as well as an object 
+            function, for converting an array of [key, value] pairs 
+            into an object.
+          
    • 
+          
  • 
+            Added a countBy function, for counting the number of objects
+            in a list that match a certain criteria.
+          
    • 
+          
  • 
+            Added an invert function, for performing a simple inversion 
+            of the keys and values in an object.
+          
    • 
+          
  • 
+            Added a where function, for easy cases of filtering a list
+            for objects with specific values.
+          
    • 
+          
  • 
+            Added an omit function, for filtering an object to remove
+            certain keys.
+          
    • 
+          
  • 
+            Added a random function, to return a random number in a
+            given range.
+          
    • 
+          
  • 
+            _.debounce'd functions now return their last updated value,
+            just like _.throttle'd functions do.
+          
    • 
+          
  • 
+            The sortBy function now runs a stable sort algorithm.
+          
    • 
+          
  • 
+            Added the optional fromIndex option to indexOf and
+            lastIndexOf.
+          
    • 
+          
  • 
+            "Sparse" arrays are no longer supported in Underscore iteration
+            functions. Use a for loop instead (or better yet, an object).
+          
    • 
+          
  • 
+            The min and max functions may now be called on 
+            very large arrays.
+          
    • 
+          
  • 
+            Interpolation in templates now represents null and 
+            undefined as the empty string.
+          
    • 
+          
  • 
+            Underscore iteration functions no longer accept null values
+            as a no-op argument. You'll get an early error instead.
+          
    • 
+          
  • 
+            A number of edge-cases fixes and tweaks, which you can spot in the
+            diff.
+            Depending on how you're using Underscore, 1.4.0 may be more
+            backwards-incompatible than usual — please test when you upgrade.
+          
    • 
+        

+      

+
+      

+        1.3.3 — April 10, 2012

+        
    
+          
  • 
+            Many improvements to _.template, which now provides the
+            source of the template function as a property, for potentially
+            even more efficient pre-compilation on the server-side. You may now
+            also set the variable option when creating a template,
+            which will cause your passed-in data to be made available under the
+            variable you named, instead of using a with statement —
+            significantly improving the speed of rendering the template.
+          
    • 
+          
  • 
+            Added the pick function, which allows you to filter an
+            object literal with a whitelist of allowed property names.
+          
    • 
+          
  • 
+            Added the result function, for convenience when working
+            with APIs that allow either functions or raw properties.
+          
    • 
+          
  • 
+            Added the isFinite function, because sometimes knowing that
+            a value is a number just ain't quite enough.
+          
    • 
+          
  • 
+            The sortBy function may now also be passed the string name
+            of a property to use as the sort order on each object.
+          
    • 
+          
  • 
+            Fixed uniq to work with sparse arrays.
+          
    • 
+          
  • 
+            The difference function now performs a shallow flatten
+            instead of a deep one when computing array differences.
+          
    • 
+          
  • 
+            The debounce function now takes an immediate
+            parameter, which will cause the callback to fire on the leading
+            instead of the trailing edge.
+          
    • 
+        

+      

+
+      

+        1.3.1 — Jan. 23, 2012

+        
    
+          
  • 
+            Added an _.has function, as a safer way to use hasOwnProperty.
+          
    • 
+          
  • 
+            Added _.collect as an alias for _.map. Smalltalkers, rejoice.
+          
    • 
+          
  • 
+            Reverted an old change so that _.extend will correctly copy
+            over keys with undefined values again.
+          
    • 
+          
  • 
+            Bugfix to stop escaping slashes within interpolations in _.template.
+          
    • 
+        

+      

+
+      

+        1.3.0 — Jan. 11, 2012

+        
    
+          
  • 
+            Removed AMD (RequireJS) support from Underscore. If you'd like to use
+            Underscore with RequireJS, you can load it as a normal script, wrap
+            or patch your copy, or download a forked version.
+          
    • 
+        

+      

+
+      

+        1.2.4 — Jan. 4, 2012

+        
    
+          
  • 
+            You now can (and probably should, as it's simpler)
+            write _.chain(list)
+            instead of _(list).chain().
+          
    • 
+          
  • 
+            Fix for escaped characters in Underscore templates, and for supporting
+            customizations of _.templateSettings that only define one or
+            two of the required regexes.
+          
    • 
+          
  • 
+            Fix for passing an array as the first argument to an _.wrap'd function.
+          
    • 
+          
  • 
+            Improved compatibility with ClojureScript, which adds a call
+            function to String.prototype.
+          
    • 
+        

+      

+
+      

+        1.2.3 — Dec. 7, 2011

+        
    
+          
  • 
+            Dynamic scope is now preserved for compiled _.template functions,
+            so you can use the value of this if you like.
+          
    • 
+          
  • 
+            Sparse array support of _.indexOf, _.lastIndexOf.
+          
    • 
+          
  • 
+            Both _.reduce and _.reduceRight can now be passed an
+            explicitly undefined value. (There's no reason why you'd
+            want to do this.)
+          
    • 
+        

+      

+
+      

+        1.2.2 — Nov. 14, 2011

+        
    
+          
  • 
+            Continued tweaks to _.isEqual semantics. Now JS primitives are
+            considered equivalent to their wrapped versions, and arrays are compared
+            by their numeric properties only (#351).
+          
    • 
+          
  • 
+            _.escape no longer tries to be smart about not double-escaping
+            already-escaped HTML entities. Now it just escapes regardless (#350).
+          
    • 
+          
  • 
+            In _.template, you may now leave semicolons out of evaluated
+            statements if you wish: <% }) %> (#369).
+          
    • 
+          
  • 
+            _.after(callback, 0) will now trigger the callback immediately,
+            making "after" easier to use with asynchronous APIs (#366).
+          
    • 
+        

+      

+
+      

+        1.2.1 — Oct. 24, 2011

+        
    
+          
  • 
+            Several important bug fixes for _.isEqual, which should now
+            do better on mutated Arrays, and on non-Array objects with
+            length properties. (#329)
+          
    • 
+          
  • 
+            jrburke contributed Underscore exporting for AMD module loaders,
+            and tonylukasavage for Appcelerator Titanium.
+            (#335, #338)
+          
    • 
+          
  • 
+            You can now _.groupBy(list, 'property') as a shortcut for
+            grouping values by a particular common property.
+          
    • 
+          
  • 
+            _.throttle'd functions now fire immediately upon invocation,
+            and are rate-limited thereafter (#170, #266).
+          
    • 
+          
  • 
+            Most of the _.is[Type] checks no longer ducktype.
+          
    • 
+          
  • 
+            The _.bind function now also works on constructors, a-la
+            ES5 ... but you would never want to use _.bind on a
+            constructor function.
+          
    • 
+          
  • 
+            _.clone no longer wraps non-object types in Objects.
+          
    • 
+          
  • 
+            _.find and _.filter are now the preferred names for
+            _.detect and _.select.
+          
    • 
+        

+      

+
+      

+        1.2.0 — Oct. 5, 2011

+        
    
+          
  • 
+            The _.isEqual function now
+            supports true deep equality comparisons, with checks for cyclic structures,
+            thanks to Kit Cambridge.
+          
    • 
+          
  • 
+            Underscore templates now support HTML escaping interpolations, using
+            <%- ... %> syntax.
+          
    • 
+          
  • 
+            Ryan Tenney contributed _.shuffle, which uses a modified
+            Fisher-Yates to give you a shuffled copy of an array.
+          
    • 
+          
  • 
+            _.uniq can now be passed an optional iterator, to determine by
+            what criteria an object should be considered unique.
+          
    • 
+          
  • 
+            _.last now takes an optional argument which will return the last
+            N elements of the list.
+          
    • 
+          
  • 
+            A new _.initial function was added, as a mirror of _.rest,
+            which returns all the initial values of a list (except the last N).
+          
    • 
+        

+      

+
+      

+        1.1.7 — July 13, 2011

+        Added _.groupBy, which aggregates a collection into groups of like items.
+        Added _.union and _.difference, to complement the
+        (re-named) _.intersection.
+        Various improvements for support of sparse arrays.
+        _.toArray now returns a clone, if directly passed an array.
+        _.functions now also returns the names of functions that are present
+        in the prototype chain.
+      

+
+      

+        1.1.6 — April 18, 2011

+        Added _.after, which will return a function that only runs after
+        first being called a specified number of times.
+        _.invoke can now take a direct function reference.
+        _.every now requires an iterator function to be passed, which
+        mirrors the ECMA5 API.
+        _.extend no longer copies keys when the value is undefined.
+        _.bind now errors when trying to bind an undefined value.
+      

+
+      

+        1.1.5 — Mar 20, 2011

+        Added an _.defaults function, for use merging together JS objects
+        representing default options.
+        Added an _.once function, for manufacturing functions that should
+        only ever execute a single time.
+        _.bind now delegates to the native ECMAScript 5 version,
+        where available.
+        _.keys now throws an error when used on non-Object values, as in
+        ECMAScript 5.
+        Fixed a bug with _.keys when used over sparse arrays.
+      

+
+      

+        1.1.4 — Jan 9, 2011

+        Improved compliance with ES5's Array methods when passing null
+        as a value. _.wrap now correctly sets this for the
+        wrapped function. _.indexOf now takes an optional flag for
+        finding the insertion index in an array that is guaranteed to already
+        be sorted. Avoiding the use of .callee, to allow _.isArray
+        to work properly in ES5's strict mode.
+      

+
+      

+        1.1.3 — Dec 1, 2010

+        In CommonJS, Underscore may now be required with just: 

+        var _ = require("underscore").
+        Added _.throttle and _.debounce functions.
+        Removed _.breakLoop, in favor of an ECMA5-style un-break-able
+        each implementation — this removes the try/catch, and you'll now have
+        better stack traces for exceptions that are thrown within an Underscore iterator.
+        Improved the isType family of functions for better interoperability
+        with Internet Explorer host objects.
+        _.template now correctly escapes backslashes in templates.
+        Improved _.reduce compatibility with the ECMA5 version:
+        if you don't pass an initial value, the first item in the collection is used.
+        _.each no longer returns the iterated collection, for improved
+        consistency with ES5's forEach.
+      

+
+      

+        1.1.2

+        Fixed _.contains, which was mistakenly pointing at
+        _.intersect instead of _.include, like it should
+        have been. Added _.unique as an alias for _.uniq.
+      

+
+      

+        1.1.1

+        Improved the speed of _.template, and its handling of multiline
+        interpolations. Ryan Tenney contributed optimizations to many Underscore
+        functions. An annotated version of the source code is now available.
+      

+
+      

+        1.1.0

+        The method signature of _.reduce has been changed to match
+        the ECMAScript 5 signature, instead of the Ruby/Prototype.js version.
+        This is a backwards-incompatible change. _.template may now be
+        called with no arguments, and preserves whitespace. _.contains
+        is a new alias for _.include.
+      

+
+      

+        1.0.4

+        Andri Möll contributed the _.memoize
+        function, which can be used to speed up expensive repeated computations
+        by caching the results.
+      

+
+      

+        1.0.3

+        Patch that makes _.isEqual return false if any property
+        of the compared object has a NaN value. Technically the correct
+        thing to do, but of questionable semantics. Watch out for NaN comparisons.
+      

+
+      

+        1.0.2

+        Fixes _.isArguments in recent versions of Opera, which have
+        arguments objects as real Arrays.
+      

+
+      

+        1.0.1

+        Bugfix for _.isEqual, when comparing two objects with the same
+        number of undefined keys, but with different names.
+      

+
+      

+        1.0.0

+        Things have been stable for many months now, so Underscore is now
+        considered to be out of beta, at 1.0. Improvements since 0.6
+        include _.isBoolean, and the ability to have _.extend
+        take multiple source objects.
+      

+
+      

+        0.6.0

+        Major release. Incorporates a number of
+        Mile Frawley's refactors for
+        safer duck-typing on collection functions, and cleaner internals. A new
+        _.mixin method that allows you to extend Underscore with utility
+        functions of your own. Added _.times, which works the same as in
+        Ruby or Prototype.js. Native support for ECMAScript 5's Array.isArray,
+        and Object.keys.
+      

+
+      

+        0.5.8

+        Fixed Underscore's collection functions to work on
+        NodeLists and
+        HTMLCollections
+        once more, thanks to
+        Justin Tulloss.
+      

+
+      

+        0.5.7

+        A safer implementation of _.isArguments, and a
+        faster _.isNumber,
thanks to
+        Jed Schmidt.
+      

+
+      

+        0.5.6

+        Customizable delimiters for _.template, contributed by
+        Noah Sloan.
+      

+
+      

+        0.5.5

+        Fix for a bug in MobileSafari's OOP-wrapper, with the arguments object.
+      

+
+      

+        0.5.4

+        Fix for multiple single quotes within a template string for
+        _.template. See:
+        Rick Strahl's blog post.
+      

+
+      

+        0.5.2

+        New implementations of isArray, isDate, isFunction,
+        isNumber, isRegExp, and isString, thanks to
+        a suggestion from
+        Robert Kieffer.
+        Instead of doing Object#toString
+        comparisons, they now check for expected properties, which is less safe,
+        but more than an order of magnitude faster. Most other Underscore
+        functions saw minor speed improvements as a result.
+        Evgeniy Dolzhenko
+        contributed _.tap,
+        similar to Ruby 1.9's,
+        which is handy for injecting side effects (like logging) into chained calls.
+      

+
+      

+        0.5.1

+        Added an _.isArguments function. Lots of little safety checks
+        and optimizations contributed by
+        Noah Sloan and
+        Andri Möll.
+      

+
+      

+        0.5.0

+        [API Changes] _.bindAll now takes the context object as
+        its first parameter. If no method names are passed, all of the context
+        object's methods are bound to it, enabling chaining and easier binding.
+        _.functions now takes a single argument and returns the names
+        of its Function properties. Calling _.functions(_) will get you
+        the previous behavior.
+        Added _.isRegExp so that isEqual can now test for RegExp equality.
+        All of the "is" functions have been shrunk down into a single definition.
+        Karl Guertin contributed patches.
+      

+
+      

+        0.4.7

+        Added isDate, isNaN, and isNull, for completeness.
+        Optimizations for isEqual when checking equality between Arrays
+        or Dates. _.keys is now 25%–2X faster (depending on your
+        browser) which speeds up the functions that rely on it, such as _.each.
+      

+
+      

+        0.4.6

+        Added the range function, a port of the
+        Python
+        function of the same name, for generating flexibly-numbered lists
+        of integers. Original patch contributed by
+        Kirill Ishanov.
+      

+
+      

+        0.4.5

+        Added rest for Arrays and arguments objects, and aliased
+        first as head, and rest as tail,
+        thanks to Luke Sutton's patches.
+        Added tests ensuring that all Underscore Array functions also work on
+        arguments objects.
+      

+
+      

+        0.4.4

+        Added isString, and isNumber, for consistency. Fixed
+        _.isEqual(NaN, NaN) to return true (which is debatable).
+      

+
+      

+        0.4.3

+        Started using the native StopIteration object in browsers that support it.
+        Fixed Underscore setup for CommonJS environments.
+      

+
+      

+        0.4.2

+        Renamed the unwrapping function to value, for clarity.
+      

+
+      

+        0.4.1

+        Chained Underscore objects now support the Array prototype methods, so
+        that you can perform the full range of operations on a wrapped array
+        without having to break your chain. Added a breakLoop method
+        to break in the middle of any Underscore iteration. Added an
+        isEmpty function that works on arrays and objects.
+      

+
+      

+        0.4.0

+        All Underscore functions can now be called in an object-oriented style,
+        like so: _([1, 2, 3]).map(...);. Original patch provided by
+        Marc-André Cournoyer.
+        Wrapped objects can be chained through multiple
+        method invocations. A functions method
+        was added, providing a sorted list of all the functions in Underscore.
+      

+
+      

+        0.3.3

+        Added the JavaScript 1.8 function reduceRight. Aliased it
+        as foldr, and aliased reduce as foldl.
+      

+
+      

+        0.3.2

+        Now runs on stock Rhino
+        interpreters with: load("underscore.js").
+        Added identity as a utility function.
+      

+
+      

+        0.3.1

+        All iterators are now passed in the original collection as their third
+        argument, the same as JavaScript 1.6's forEach. Iterating over
+        objects is now called with (value, key, collection), for details
+        see _.each.
+      

+
+      

+        0.3.0

+        Added Dmitry Baranovskiy's
+        comprehensive optimizations, merged in
+        Kris Kowal's patches to make Underscore
+        CommonJS and
+        Narwhal compliant.
+      

+
+      

+        0.2.0

+        Added compose and lastIndexOf, renamed inject to
+        reduce, added aliases for inject, filter,
+        every, some, and forEach.
+      

+
+      

+        0.1.1

+        Added noConflict, so that the "Underscore" object can be assigned to
+        other variables.
+      

+
+      

+        0.1.0

+        Initial release of Underscore.js.
+      

+
+      

+        
+          A DocumentCloud Project
+        
+      

+
+    

+
+  

+
+  
+  
+
+
+
diff --git a/underscore/index.js b/underscore/index.js
new file mode 100644
index 0000000..2cf0ca5
--- /dev/null
+++ b/underscore/index.js
@@ -0,0 +1 @@
+module.exports = require('./underscore');
diff --git a/underscore/package.json b/underscore/package.json
new file mode 100644
index 0000000..849d817
--- /dev/null
+++ b/underscore/package.json
@@ -0,0 +1,10 @@
+{
+  "name"          : "underscore",
+  "description"   : "JavaScript's functional programming helper library.",
+  "homepage"      : "http://underscorejs.org",
+  "keywords"      : ["util", "functional", "server", "client", "browser"],
+  "author"        : "Jeremy Ashkenas ",
+  "repository"    : {"type": "git", "url": "git://github.com/documentcloud/underscore.git"},
+  "main"          : "underscore.js",
+  "version"       : "1.4.2"
+}
diff --git a/underscore/test/arrays.js b/underscore/test/arrays.js
new file mode 100644
index 0000000..32252a3
--- /dev/null
+++ b/underscore/test/arrays.js
@@ -0,0 +1,200 @@
+$(document).ready(function() {
+
+  module("Arrays");
+
+  test("first", function() {
+    equal(_.first([1,2,3]), 1, 'can pull out the first element of an array');
+    equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
+    equal(_.first([1,2,3], 0).join(', '), "", 'can pass an index to first');
+    equal(_.first([1,2,3], 2).join(', '), '1, 2', 'can pass an index to first');
+    equal(_.first([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to first');
+    var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
+    equal(result, 4, 'works on an arguments object.');
+    result = _.map([[1,2,3],[1,2,3]], _.first);
+    equal(result.join(','), '1,1', 'works well with _.map');
+    result = (function() { return _.take([1,2,3], 2); })();
+    equal(result.join(','), '1,2', 'aliased as take');
+
+    equal(_.first(null), undefined, 'handles nulls');
+  });
+
+  test("rest", function() {
+    var numbers = [1, 2, 3, 4];
+    equal(_.rest(numbers).join(", "), "2, 3, 4", 'working rest()');
+    equal(_.rest(numbers, 0).join(", "), "1, 2, 3, 4", 'working rest(0)');
+    equal(_.rest(numbers, 2).join(', '), '3, 4', 'rest can take an index');
+    var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
+    equal(result.join(', '), '2, 3, 4', 'aliased as tail and works on arguments object');
+    result = _.map([[1,2,3],[1,2,3]], _.rest);
+    equal(_.flatten(result).join(','), '2,3,2,3', 'works well with _.map');
+    result = (function(){ return _(arguments).drop(); })(1, 2, 3, 4);
+    equal(result.join(', '), '2, 3, 4', 'aliased as drop and works on arguments object');
+  });
+
+  test("initial", function() {
+    equal(_.initial([1,2,3,4,5]).join(", "), "1, 2, 3, 4", 'working initial()');
+    equal(_.initial([1,2,3,4],2).join(", "), "1, 2", 'initial can take an index');
+    var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
+    equal(result.join(", "), "1, 2, 3", 'initial works on arguments object');
+    result = _.map([[1,2,3],[1,2,3]], _.initial);
+    equal(_.flatten(result).join(','), '1,2,1,2', 'initial works with _.map');
+  });
+
+  test("last", function() {
+    equal(_.last([1,2,3]), 3, 'can pull out the last element of an array');
+    equal(_.last([1,2,3], 0).join(', '), "", 'can pass an index to last');
+    equal(_.last([1,2,3], 2).join(', '), '2, 3', 'can pass an index to last');
+    equal(_.last([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to last');
+    var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
+    equal(result, 4, 'works on an arguments object');
+    result = _.map([[1,2,3],[1,2,3]], _.last);
+    equal(result.join(','), '3,3', 'works well with _.map');
+
+    equal(_.last(null), undefined, 'handles nulls');
+  });
+
+  test("compact", function() {
+    equal(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
+    var result = (function(){ return _(arguments).compact().length; })(0, 1, false, 2, false, 3);
+    equal(result, 3, 'works on an arguments object');
+  });
+
+  test("flatten", function() {
+    if (window.JSON) {
+      var list = [1, [2], [3, [[[4]]]]];
+      equal(JSON.stringify(_.flatten(list)), '[1,2,3,4]', 'can flatten nested arrays');
+      equal(JSON.stringify(_.flatten(list, true)), '[1,2,3,[[[4]]]]', 'can shallowly flatten nested arrays');
+      var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
+      equal(JSON.stringify(result), '[1,2,3,4]', 'works on an arguments object');
+    }
+  });
+
+  test("without", function() {
+    var list = [1, 2, 1, 0, 3, 1, 4];
+    equal(_.without(list, 0, 1).join(', '), '2, 3, 4', 'can remove all instances of an object');
+    var result = (function(){ return _.without(arguments, 0, 1); })(1, 2, 1, 0, 3, 1, 4);
+    equal(result.join(', '), '2, 3, 4', 'works on an arguments object');
+
+    var list = [{one : 1}, {two : 2}];
+    ok(_.without(list, {one : 1}).length == 2, 'uses real object identity for comparisons.');
+    ok(_.without(list, list[0]).length == 1, 'ditto.');
+  });
+
+  test("uniq", function() {
+    var list = [1, 2, 1, 3, 1, 4];
+    equal(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');
+
+    var list = [1, 1, 1, 2, 2, 3];
+    equal(_.uniq(list, true).join(', '), '1, 2, 3', 'can find the unique values of a sorted array faster');
+
+    var list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
+    var iterator = function(value) { return value.name; };
+    equal(_.map(_.uniq(list, false, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator');
+
+    var iterator = function(value) { return value +1; };
+    var list = [1, 2, 2, 3, 4, 4];
+    equal(_.uniq(list, true, iterator).join(', '), '1, 2, 3, 4', 'iterator works with sorted array');
+
+    var result = (function(){ return _.uniq(arguments); })(1, 2, 1, 3, 1, 4);
+    equal(result.join(', '), '1, 2, 3, 4', 'works on an arguments object');
+  });
+
+  test("intersection", function() {
+    var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
+    equal(_.intersection(stooges, leaders).join(''), 'moe', 'can take the set intersection of two arrays');
+    equal(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
+    var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
+    equal(result.join(''), 'moe', 'works on an arguments object');
+  });
+
+  test("union", function() {
+    var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
+    equal(result.join(' '), '1 2 3 30 40', 'takes the union of a list of arrays');
+
+    var result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
+    equal(result.join(' '), '1 2 3 30 40 1', 'takes the union of a list of nested arrays');
+  });
+
+  test("difference", function() {
+    var result = _.difference([1, 2, 3], [2, 30, 40]);
+    equal(result.join(' '), '1 3', 'takes the difference of two arrays');
+
+    var result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
+    equal(result.join(' '), '3 4', 'takes the difference of three arrays');
+  });
+
+  test('zip', function() {
+    var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
+    var stooges = _.zip(names, ages, leaders);
+    equal(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
+  });
+
+  test('object', function() {
+    var result = _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+    var shouldBe = {moe: 30, larry: 40, curly: 50};
+    ok(_.isEqual(result, shouldBe), 'two arrays zipped together into an object');
+
+    result = _.object([['one', 1], ['two', 2], ['three', 3]]);
+    shouldBe = {one: 1, two: 2, three: 3};
+    ok(_.isEqual(result, shouldBe), 'an array of pairs zipped together into an object');
+
+    var stooges = {moe: 30, larry: 40, curly: 50};
+    ok(_.isEqual(_.object(_.pairs(stooges)), stooges), 'an object converted to pairs and back to an object');
+
+    ok(_.isEqual(_.object(null), {}), 'handles nulls');
+  });
+
+  test("indexOf", function() {
+    var numbers = [1, 2, 3];
+    numbers.indexOf = null;
+    equal(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function');
+    var result = (function(){ return _.indexOf(arguments, 2); })(1, 2, 3);
+    equal(result, 1, 'works on an arguments object');
+    equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+    var numbers = [10, 20, 30, 40, 50], num = 35;
+    var index = _.indexOf(numbers, num, true);
+    equal(index, -1, '35 is not in the list');
+
+    numbers = [10, 20, 30, 40, 50]; num = 40;
+    index = _.indexOf(numbers, num, true);
+    equal(index, 3, '40 is in the list');
+
+    numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
+    index = _.indexOf(numbers, num, true);
+    equal(index, 1, '40 is in the list');
+
+    numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+    index = _.indexOf(numbers, 2, 5);
+    equal(index, 7, 'supports the fromIndex argument');
+  });
+
+  test("lastIndexOf", function() {
+    var numbers = [1, 0, 1];
+    equal(_.lastIndexOf(numbers, 1), 2);
+
+    numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
+    numbers.lastIndexOf = null;
+    equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
+    equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
+    var result = (function(){ return _.lastIndexOf(arguments, 1); })(1, 0, 1, 0, 0, 1, 0, 0, 0);
+    equal(result, 5, 'works on an arguments object');
+    equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+    numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+    index = _.lastIndexOf(numbers, 2, 2);
+    equal(index, 1, 'supports the fromIndex argument');
+  });
+
+  test("range", function() {
+    equal(_.range(0).join(''), '', 'range with 0 as a first argument generates an empty array');
+    equal(_.range(4).join(' '), '0 1 2 3', 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
+    equal(_.range(5, 8).join(' '), '5 6 7', 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
+    equal(_.range(8, 5).join(''), '', 'range with two arguments a & b, b<a generates an empty array');
+    equal(_.range(3, 10, 3).join(' '), '3 6 9', 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
+    equal(_.range(3, 10, 15).join(''), '3', 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
+    equal(_.range(12, 7, -2).join(' '), '12 10 8', 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
+    equal(_.range(0, -10, -1).join(' '), '0 -1 -2 -3 -4 -5 -6 -7 -8 -9', 'final example in the Python docs');
+  });
+
+});
diff --git a/underscore/test/chaining.js b/underscore/test/chaining.js
new file mode 100644
index 0000000..16cf7bf
--- /dev/null
+++ b/underscore/test/chaining.js
@@ -0,0 +1,59 @@
+$(document).ready(function() {
+
+  module("Chaining");
+
+  test("map/flatten/reduce", function() {
+    var lyrics = [
+      "I'm a lumberjack and I'm okay",
+      "I sleep all night and I work all day",
+      "He's a lumberjack and he's okay",
+      "He sleeps all night and he works all day"
+    ];
+    var counts = _(lyrics).chain()
+      .map(function(line) { return line.split(''); })
+      .flatten()
+      .reduce(function(hash, l) {
+        hash[l] = hash[l] || 0;
+        hash[l]++;
+        return hash;
+    }, {}).value();
+    ok(counts['a'] == 16 && counts['e'] == 10, 'counted all the letters in the song');
+  });
+
+  test("select/reject/sortBy", function() {
+    var numbers = [1,2,3,4,5,6,7,8,9,10];
+    numbers = _(numbers).chain().select(function(n) {
+      return n % 2 == 0;
+    }).reject(function(n) {
+      return n % 4 == 0;
+    }).sortBy(function(n) {
+      return -n;
+    }).value();
+    equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+  });
+
+  test("select/reject/sortBy in functional style", function() {
+    var numbers = [1,2,3,4,5,6,7,8,9,10];
+    numbers = _.chain(numbers).select(function(n) {
+      return n % 2 == 0;
+    }).reject(function(n) {
+      return n % 4 == 0;
+    }).sortBy(function(n) {
+      return -n;
+    }).value();
+    equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+  });
+
+  test("reverse/concat/unshift/pop/map", function() {
+    var numbers = [1,2,3,4,5];
+    numbers = _(numbers).chain()
+      .reverse()
+      .concat([5, 5, 5])
+      .unshift(17)
+      .pop()
+      .map(function(n){ return n * 2; })
+      .value();
+    equal(numbers.join(', '), "34, 10, 8, 6, 4, 2, 10, 10", 'can chain together array functions.');
+  });
+
+});
diff --git a/underscore/test/collections.js b/underscore/test/collections.js
new file mode 100644
index 0000000..7dce44b
--- /dev/null
+++ b/underscore/test/collections.js
@@ -0,0 +1,418 @@
+$(document).ready(function() {
+
+  module("Collections");
+
+  test("each", function() {
+    _.each([1, 2, 3], function(num, i) {
+      equal(num, i + 1, 'each iterators provide value and iteration count');
+    });
+
+    var answers = [];
+    _.each([1, 2, 3], function(num){ answers.push(num * this.multiplier);}, {multiplier : 5});
+    equal(answers.join(', '), '5, 10, 15', 'context object property accessed');
+
+    answers = [];
+    _.forEach([1, 2, 3], function(num){ answers.push(num); });
+    equal(answers.join(', '), '1, 2, 3', 'aliased as "forEach"');
+
+    answers = [];
+    var obj = {one : 1, two : 2, three : 3};
+    obj.constructor.prototype.four = 4;
+    _.each(obj, function(value, key){ answers.push(key); });
+    equal(answers.join(", "), 'one, two, three', 'iterating over objects works, and ignores the object prototype.');
+    delete obj.constructor.prototype.four;
+
+    answer = null;
+    _.each([1, 2, 3], function(num, index, arr){ if (_.include(arr, num)) answer = true; });
+    ok(answer, 'can reference the original collection from inside the iterator');
+
+    answers = 0;
+    _.each(null, function(){ ++answers; });
+    equal(answers, 0, 'handles a null properly');
+  });
+
+  test('map', function() {
+    var doubled = _.map([1, 2, 3], function(num){ return num * 2; });
+    equal(doubled.join(', '), '2, 4, 6', 'doubled numbers');
+
+    doubled = _.collect([1, 2, 3], function(num){ return num * 2; });
+    equal(doubled.join(', '), '2, 4, 6', 'aliased as "collect"');
+
+    var tripled = _.map([1, 2, 3], function(num){ return num * this.multiplier; }, {multiplier : 3});
+    equal(tripled.join(', '), '3, 6, 9', 'tripled numbers with context');
+
+    var doubled = _([1, 2, 3]).map(function(num){ return num * 2; });
+    equal(doubled.join(', '), '2, 4, 6', 'OO-style doubled numbers');
+
+    if (document.querySelectorAll) {
+      var ids = _.map(document.querySelectorAll('#map-test *'), function(n){ return n.id; });
+      deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on NodeLists.');
+    }
+
+    var ids = _.map($('#map-test').children(), function(n){ return n.id; });
+    deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on jQuery Array-likes.');
+
+    var ids = _.map(document.images, function(n){ return n.id; });
+    ok(ids[0] == 'chart_image', 'can use collection methods on HTMLCollections');
+
+    var ifnull = _.map(null, function(){});
+    ok(_.isArray(ifnull) && ifnull.length === 0, 'handles a null properly');
+  });
+
+  test('reduce', function() {
+    var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+    equal(sum, 6, 'can sum up an array');
+
+    var context = {multiplier : 3};
+    sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num * this.multiplier; }, 0, context);
+    equal(sum, 18, 'can reduce with a context object');
+
+    sum = _.inject([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+    equal(sum, 6, 'aliased as "inject"');
+
+    sum = _([1, 2, 3]).reduce(function(sum, num){ return sum + num; }, 0);
+    equal(sum, 6, 'OO-style reduce');
+
+    var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; });
+    equal(sum, 6, 'default initial value');
+
+    var ifnull;
+    try {
+      _.reduce(null, function(){});
+    } catch (ex) {
+      ifnull = ex;
+    }
+    ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+    ok(_.reduce(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+    equal(_.reduce([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+    raises(function() { _.reduce([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+  });
+
+  test('reduceRight', function() {
+    var list = _.reduceRight(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+    equal(list, 'bazbarfoo', 'can perform right folds');
+
+    var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+    equal(list, 'bazbarfoo', 'aliased as "foldr"');
+
+    var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; });
+    equal(list, 'bazbarfoo', 'default initial value');
+
+    var ifnull;
+    try {
+      _.reduceRight(null, function(){});
+    } catch (ex) {
+      ifnull = ex;
+    }
+    ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+    var sum = _.reduceRight({a: 1, b: 2, c: 3}, function(sum, num){ return sum + num; });
+    equal(sum, 6, 'default initial value on object');
+
+    ok(_.reduceRight(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+
+    equal(_.reduceRight([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+    raises(function() { _.reduceRight([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+
+    // Assert that the correct arguments are being passed.
+
+    var args,
+        memo = {},
+        object = {a: 1, b: 2},
+        lastKey = _.keys(object).pop();
+
+    var expected = lastKey == 'a'
+      ? [memo, 1, 'a', object]
+      : [memo, 2, 'b', object];
+
+    _.reduceRight(object, function() {
+      args || (args = _.toArray(arguments));
+    }, memo);
+
+    deepEqual(args, expected);
+
+    // And again, with numeric keys.
+
+    object = {'2': 'a', '1': 'b'};
+    lastKey = _.keys(object).pop();
+    args = null;
+
+    expected = lastKey == '2'
+      ? [memo, 'a', '2', object]
+      : [memo, 'b', '1', object];
+
+    _.reduceRight(object, function() {
+      args || (args = _.toArray(arguments));
+    }, memo);
+
+    deepEqual(args, expected);
+  });
+
+  test('find', function() {
+    var array = [1, 2, 3, 4];
+    strictEqual(_.find(array, function(n) { return n > 2; }), 3, 'should return first found `value`');
+    strictEqual(_.find(array, function() { return false; }), void 0, 'should return `undefined` if `value` is not found');
+  });
+
+  test('detect', function() {
+    var result = _.detect([1, 2, 3], function(num){ return num * 2 == 4; });
+    equal(result, 2, 'found the first "2" and broke the loop');
+  });
+
+  test('select', function() {
+    var evens = _.select([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+    equal(evens.join(', '), '2, 4, 6', 'selected each even number');
+
+    evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+    equal(evens.join(', '), '2, 4, 6', 'aliased as "filter"');
+  });
+
+  test('reject', function() {
+    var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+    equal(odds.join(', '), '1, 3, 5', 'rejected each even number');
+  });
+
+  test('all', function() {
+    ok(_.all([], _.identity), 'the empty set');
+    ok(_.all([true, true, true], _.identity), 'all true values');
+    ok(!_.all([true, false, true], _.identity), 'one false value');
+    ok(_.all([0, 10, 28], function(num){ return num % 2 == 0; }), 'even numbers');
+    ok(!_.all([0, 11, 28], function(num){ return num % 2 == 0; }), 'an odd number');
+    ok(_.all([1], _.identity) === true, 'cast to boolean - true');
+    ok(_.all([0], _.identity) === false, 'cast to boolean - false');
+    ok(_.every([true, true, true], _.identity), 'aliased as "every"');
+    ok(!_.all([undefined, undefined, undefined], _.identity), 'works with arrays of undefined');
+  });
+
+  test('any', function() {
+    var nativeSome = Array.prototype.some;
+    Array.prototype.some = null;
+    ok(!_.any([]), 'the empty set');
+    ok(!_.any([false, false, false]), 'all false values');
+    ok(_.any([false, false, true]), 'one true value');
+    ok(_.any([null, 0, 'yes', false]), 'a string');
+    ok(!_.any([null, 0, '', false]), 'falsy values');
+    ok(!_.any([1, 11, 29], function(num){ return num % 2 == 0; }), 'all odd numbers');
+    ok(_.any([1, 10, 29], function(num){ return num % 2 == 0; }), 'an even number');
+    ok(_.any([1], _.identity) === true, 'cast to boolean - true');
+    ok(_.any([0], _.identity) === false, 'cast to boolean - false');
+    ok(_.some([false, false, true]), 'aliased as "some"');
+    Array.prototype.some = nativeSome;
+  });
+
+  test('include', function() {
+    ok(_.include([1,2,3], 2), 'two is in the array');
+    ok(!_.include([1,3,9], 2), 'two is not in the array');
+    ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
+    ok(_([1,2,3]).include(2), 'OO-style include');
+  });
+
+  test('invoke', function() {
+    var list = [[5, 1, 7], [3, 2, 1]];
+    var result = _.invoke(list, 'sort');
+    equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+    equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+  });
+
+  test('invoke w/ function reference', function() {
+    var list = [[5, 1, 7], [3, 2, 1]];
+    var result = _.invoke(list, Array.prototype.sort);
+    equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+    equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+  });
+
+  // Relevant when using ClojureScript
+  test('invoke when strings have a call method', function() {
+    String.prototype.call = function() {
+      return 42;
+    };
+    var list = [[5, 1, 7], [3, 2, 1]];
+    var s = "foo";
+    equal(s.call(), 42, "call function exists");
+    var result = _.invoke(list, 'sort');
+    equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+    equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+    delete String.prototype.call;
+    equal(s.call, undefined, "call function removed");
+  });
+
+  test('pluck', function() {
+    var people = [{name : 'moe', age : 30}, {name : 'curly', age : 50}];
+    equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'pulls names out of objects');
+  });
+
+  test('where', function() {
+    var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}];
+    var result = _.where(list, {a: 1});
+    equal(result.length, 3);
+    equal(result[result.length - 1].b, 4);
+    result = _.where(list, {b: 2});
+    equal(result.length, 2);
+    equal(result[0].a, 1);
+  });
+
+  test('max', function() {
+    equal(3, _.max([1, 2, 3]), 'can perform a regular Math.max');
+
+    var neg = _.max([1, 2, 3], function(num){ return -num; });
+    equal(neg, 1, 'can perform a computation-based max');
+
+    equal(-Infinity, _.max({}), 'Maximum value of an empty object');
+    equal(-Infinity, _.max([]), 'Maximum value of an empty array');
+
+    equal(299999, _.max(_.range(1,300000)), "Maximum value of a too-big array");
+  });
+
+  test('min', function() {
+    equal(1, _.min([1, 2, 3]), 'can perform a regular Math.min');
+
+    var neg = _.min([1, 2, 3], function(num){ return -num; });
+    equal(neg, 3, 'can perform a computation-based min');
+
+    equal(Infinity, _.min({}), 'Minimum value of an empty object');
+    equal(Infinity, _.min([]), 'Minimum value of an empty array');
+
+    var now = new Date(9999999999);
+    var then = new Date(0);
+    equal(_.min([now, then]), then);
+
+    equal(1, _.min(_.range(1,300000)), "Minimum value of a too-big array");
+  });
+
+  test('sortBy', function() {
+    var people = [{name : 'curly', age : 50}, {name : 'moe', age : 30}];
+    people = _.sortBy(people, function(person){ return person.age; });
+    equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'stooges sorted by age');
+
+    var list = [undefined, 4, 1, undefined, 3, 2];
+    equal(_.sortBy(list, _.identity).join(','), '1,2,3,4,,', 'sortBy with undefined values');
+
+    var list = ["one", "two", "three", "four", "five"];
+    var sorted = _.sortBy(list, 'length');
+    equal(sorted.join(' '), 'one two four five three', 'sorted by length');
+
+    function Pair(x, y) {
+      this.x = x;
+      this.y = y;
+    }
+
+    var collection = [
+      new Pair(1, 1), new Pair(1, 2),
+      new Pair(1, 3), new Pair(1, 4),
+      new Pair(1, 5), new Pair(1, 6),
+      new Pair(2, 1), new Pair(2, 2),
+      new Pair(2, 3), new Pair(2, 4),
+      new Pair(2, 5), new Pair(2, 6),
+      new Pair(undefined, 1), new Pair(undefined, 2),
+      new Pair(undefined, 3), new Pair(undefined, 4),
+      new Pair(undefined, 5), new Pair(undefined, 6)
+    ];
+
+    var actual = _.sortBy(collection, function(pair) {
+      return pair.x;
+    });
+
+    deepEqual(actual, collection, 'sortBy should be stable');
+  });
+
+  test('groupBy', function() {
+    var parity = _.groupBy([1, 2, 3, 4, 5, 6], function(num){ return num % 2; });
+    ok('0' in parity && '1' in parity, 'created a group for each value');
+    equal(parity[0].join(', '), '2, 4, 6', 'put each even number in the right group');
+
+    var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+    var grouped = _.groupBy(list, 'length');
+    equal(grouped['3'].join(' '), 'one two six ten');
+    equal(grouped['4'].join(' '), 'four five nine');
+    equal(grouped['5'].join(' '), 'three seven eight');
+
+    var context = {};
+    _.groupBy([{}], function(){ ok(this === context); }, context);
+
+    grouped = _.groupBy([4.2, 6.1, 6.4], function(num) {
+      return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+    });
+    equal(grouped.constructor.length, 1);
+    equal(grouped.hasOwnProperty.length, 2);
+
+    var array = [{}];
+    _.groupBy(array, function(value, index, obj){ ok(obj === array); });
+  });
+
+  test('countBy', function() {
+    var parity = _.countBy([1, 2, 3, 4, 5], function(num){ return num % 2 == 0; });
+    equal(parity['true'], 2);
+    equal(parity['false'], 3);
+
+    var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+    var grouped = _.countBy(list, 'length');
+    equal(grouped['3'], 4);
+    equal(grouped['4'], 3);
+    equal(grouped['5'], 3);
+
+    var context = {};
+    _.countBy([{}], function(){ ok(this === context); }, context);
+
+    grouped = _.countBy([4.2, 6.1, 6.4], function(num) {
+      return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+    });
+    equal(grouped.constructor, 1);
+    equal(grouped.hasOwnProperty, 2);
+
+    var array = [{}];
+    _.countBy(array, function(value, index, obj){ ok(obj === array); });
+  });
+
+  test('sortedIndex', function() {
+    var numbers = [10, 20, 30, 40, 50], num = 35;
+    var indexForNum = _.sortedIndex(numbers, num);
+    equal(indexForNum, 3, '35 should be inserted at index 3');
+
+    var indexFor30 = _.sortedIndex(numbers, 30);
+    equal(indexFor30, 2, '30 should be inserted at index 2');
+
+    var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
+    var iterator = function(obj){ return obj.x; };
+    strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
+    strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
+
+    var context = {1: 2, 2: 3, 3: 4};
+    iterator = function(obj){ return this[obj]; };
+    strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
+  });
+
+  test('shuffle', function() {
+    var numbers = _.range(10);
+    var shuffled = _.shuffle(numbers).sort();
+    notStrictEqual(numbers, shuffled, 'original object is unmodified');
+    equal(shuffled.join(','), numbers.join(','), 'contains the same members before and after shuffle');
+  });
+
+  test('toArray', function() {
+    ok(!_.isArray(arguments), 'arguments object is not an array');
+    ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
+    var a = [1,2,3];
+    ok(_.toArray(a) !== a, 'array is cloned');
+    equal(_.toArray(a).join(', '), '1, 2, 3', 'cloned array contains same elements');
+
+    var numbers = _.toArray({one : 1, two : 2, three : 3});
+    equal(numbers.join(', '), '1, 2, 3', 'object flattened into array');
+  });
+
+  test('size', function() {
+    equal(_.size({one : 1, two : 2, three : 3}), 3, 'can compute the size of an object');
+    equal(_.size([1, 2, 3]), 3, 'can compute the size of an array');
+
+    var func = function() {
+      return _.size(arguments);
+    };
+
+    equal(func(1, 2, 3, 4), 4, 'can test the size of the arguments object');
+
+    equal(_.size('hello'), 5, 'can compute the size of a string');
+
+    equal(_.size(null), 0, 'handles nulls');
+  });
+
+});
diff --git a/underscore/test/functions.js b/underscore/test/functions.js
new file mode 100644
index 0000000..a529658
--- /dev/null
+++ b/underscore/test/functions.js
@@ -0,0 +1,259 @@
+$(document).ready(function() {
+
+  module("Functions");
+
+  test("bind", function() {
+    var context = {name : 'moe'};
+    var func = function(arg) { return "name: " + (this.name || arg); };
+    var bound = _.bind(func, context);
+    equal(bound(), 'name: moe', 'can bind a function to a context');
+
+    bound = _(func).bind(context);
+    equal(bound(), 'name: moe', 'can do OO-style binding');
+
+    bound = _.bind(func, null, 'curly');
+    equal(bound(), 'name: curly', 'can bind without specifying a context');
+
+    func = function(salutation, name) { return salutation + ': ' + name; };
+    func = _.bind(func, this, 'hello');
+    equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
+
+    var func = _.bind(func, this, 'curly');
+    equal(func(), 'hello: curly', 'the function was completely applied in advance');
+
+    var func = function(salutation, firstname, lastname) { return salutation + ': ' + firstname + ' ' + lastname; };
+    func = _.bind(func, this, 'hello', 'moe', 'curly');
+    equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
+
+    func = function(context, message) { equal(this, context, message); };
+    _.bind(func, 0, 0, 'can bind a function to `0`')();
+    _.bind(func, '', '', 'can bind a function to an empty string')();
+    _.bind(func, false, false, 'can bind a function to `false`')();
+
+    // These tests are only meaningful when using a browser without a native bind function
+    // To test this with a modern browser, set underscore's nativeBind to undefined
+    var F = function () { return this; };
+    var Boundf = _.bind(F, {hello: "moe curly"});
+    equal(new Boundf().hello, undefined, "function should not be bound to the context, to comply with ECMAScript 5");
+    equal(Boundf().hello, "moe curly", "When called without the new operator, it's OK to be bound to the context");
+  });
+
+  test("bindAll", function() {
+    var curly = {name : 'curly'}, moe = {
+      name    : 'moe',
+      getName : function() { return 'name: ' + this.name; },
+      sayHi   : function() { return 'hi: ' + this.name; }
+    };
+    curly.getName = moe.getName;
+    _.bindAll(moe, 'getName', 'sayHi');
+    curly.sayHi = moe.sayHi;
+    equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
+    equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
+
+    curly = {name : 'curly'};
+    moe = {
+      name    : 'moe',
+      getName : function() { return 'name: ' + this.name; },
+      sayHi   : function() { return 'hi: ' + this.name; }
+    };
+    _.bindAll(moe);
+    curly.sayHi = moe.sayHi;
+    equal(curly.sayHi(), 'hi: moe', 'calling bindAll with no arguments binds all functions to the object');
+  });
+
+  test("memoize", function() {
+    var fib = function(n) {
+      return n < 2 ? n : fib(n - 1) + fib(n - 2);
+    };
+    var fastFib = _.memoize(fib);
+    equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
+    equal(fastFib(10), 55, 'a memoized version of fibonacci produces identical results');
+
+    var o = function(str) {
+      return str;
+    };
+    var fastO = _.memoize(o);
+    equal(o('toString'), 'toString', 'checks hasOwnProperty');
+    equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
+  });
+
+  asyncTest("delay", 2, function() {
+    var delayed = false;
+    _.delay(function(){ delayed = true; }, 100);
+    setTimeout(function(){ ok(!delayed, "didn't delay the function quite yet"); }, 50);
+    setTimeout(function(){ ok(delayed, 'delayed the function'); start(); }, 150);
+  });
+
+  asyncTest("defer", 1, function() {
+    var deferred = false;
+    _.defer(function(bool){ deferred = bool; }, true);
+    _.delay(function(){ ok(deferred, "deferred the function"); start(); }, 50);
+  });
+
+  asyncTest("throttle", 2, function() {
+    var counter = 0;
+    var incr = function(){ counter++; };
+    var throttledIncr = _.throttle(incr, 100);
+    throttledIncr(); throttledIncr(); throttledIncr();
+    setTimeout(throttledIncr, 70);
+    setTimeout(throttledIncr, 120);
+    setTimeout(throttledIncr, 140);
+    setTimeout(throttledIncr, 190);
+    setTimeout(throttledIncr, 220);
+    setTimeout(throttledIncr, 240);
+    _.delay(function(){ equal(counter, 1, "incr was called immediately"); }, 30);
+    _.delay(function(){ equal(counter, 4, "incr was throttled"); start(); }, 400);
+  });
+
+  asyncTest("throttle arguments", 2, function() {
+    var value = 0;
+    var update = function(val){ value = val; };
+    var throttledUpdate = _.throttle(update, 100);
+    throttledUpdate(1); throttledUpdate(2); throttledUpdate(3);
+    setTimeout(function(){ throttledUpdate(4); }, 120);
+    setTimeout(function(){ throttledUpdate(5); }, 140);
+    setTimeout(function(){ throttledUpdate(6); }, 250);
+    _.delay(function(){ equal(value, 1, "updated to latest value"); }, 40);
+    _.delay(function(){ equal(value, 6, "updated to latest value"); start(); }, 400);
+  });
+
+  asyncTest("throttle once", 2, function() {
+    var counter = 0;
+    var incr = function(){ return ++counter; };
+    var throttledIncr = _.throttle(incr, 100);
+    var result = throttledIncr();
+    _.delay(function(){
+      equal(result, 1, "throttled functions return their value");
+      equal(counter, 1, "incr was called once"); start();
+    }, 220);
+  });
+
+  asyncTest("throttle twice", 1, function() {
+    var counter = 0;
+    var incr = function(){ counter++; };
+    var throttledIncr = _.throttle(incr, 100);
+    throttledIncr(); throttledIncr();
+    _.delay(function(){ equal(counter, 2, "incr was called twice"); start(); }, 220);
+  });
+
+  asyncTest("throttle repeatedly with results", 9, function() {
+    var counter = 0;
+    var incr = function(){ return ++counter; };
+    var throttledIncr = _.throttle(incr, 100);
+    var results = [];
+    var saveResult = function() { results.push(throttledIncr()); };
+    saveResult(); saveResult(); saveResult();
+    setTimeout(saveResult, 70);
+    setTimeout(saveResult, 120);
+    setTimeout(saveResult, 140);
+    setTimeout(saveResult, 190);
+    setTimeout(saveResult, 240);
+    setTimeout(saveResult, 260);
+    _.delay(function() {
+      equal(results[0], 1, "incr was called once");
+      equal(results[1], 1, "incr was throttled");
+      equal(results[2], 1, "incr was throttled");
+      equal(results[3], 1, "incr was throttled");
+      equal(results[4], 2, "incr was called twice");
+      equal(results[5], 2, "incr was throttled");
+      equal(results[6], 2, "incr was throttled");
+      equal(results[7], 3, "incr was called thrice");
+      equal(results[8], 3, "incr was throttled");
+      start();
+    }, 400);
+  });
+
+  asyncTest("debounce", 1, function() {
+    var counter = 0;
+    var incr = function(){ counter++; };
+    var debouncedIncr = _.debounce(incr, 50);
+    debouncedIncr(); debouncedIncr(); debouncedIncr();
+    setTimeout(debouncedIncr, 30);
+    setTimeout(debouncedIncr, 60);
+    setTimeout(debouncedIncr, 90);
+    setTimeout(debouncedIncr, 120);
+    setTimeout(debouncedIncr, 150);
+    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+  });
+
+  asyncTest("debounce asap", 5, function() {
+    var a, b, c;
+    var counter = 0;
+    var incr = function(){ return ++counter; };
+    var debouncedIncr = _.debounce(incr, 50, true);
+    a = debouncedIncr();
+    b = debouncedIncr();
+    c = debouncedIncr();
+    equal(a, 1);
+    equal(b, 1);
+    equal(c, 1);
+    equal(counter, 1, 'incr was called immediately');
+    setTimeout(debouncedIncr, 30);
+    setTimeout(debouncedIncr, 60);
+    setTimeout(debouncedIncr, 90);
+    setTimeout(debouncedIncr, 120);
+    setTimeout(debouncedIncr, 150);
+    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+  });
+
+  asyncTest("debounce asap recursively", 2, function() {
+    var counter = 0;
+    var debouncedIncr = _.debounce(function(){
+      counter++;
+      if (counter < 5) debouncedIncr();
+    }, 50, true);
+    debouncedIncr();
+    equal(counter, 1, 'incr was called immediately');
+    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 70);
+  });
+
+  test("once", function() {
+    var num = 0;
+    var increment = _.once(function(){ num++; });
+    increment();
+    increment();
+    equal(num, 1);
+  });
+
+  test("wrap", function() {
+    var greet = function(name){ return "hi: " + name; };
+    var backwards = _.wrap(greet, function(func, name){ return func(name) + ' ' + name.split('').reverse().join(''); });
+    equal(backwards('moe'), 'hi: moe eom', 'wrapped the saluation function');
+
+    var inner = function(){ return "Hello "; };
+    var obj   = {name : "Moe"};
+    obj.hi    = _.wrap(inner, function(fn){ return fn() + this.name; });
+    equal(obj.hi(), "Hello Moe");
+
+    var noop    = function(){};
+    var wrapped = _.wrap(noop, function(fn){ return Array.prototype.slice.call(arguments, 0); });
+    var ret     = wrapped(['whats', 'your'], 'vector', 'victor');
+    deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
+  });
+
+  test("compose", function() {
+    var greet = function(name){ return "hi: " + name; };
+    var exclaim = function(sentence){ return sentence + '!'; };
+    var composed = _.compose(exclaim, greet);
+    equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
+
+    composed = _.compose(greet, exclaim);
+    equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
+  });
+
+  test("after", function() {
+    var testAfter = function(afterAmount, timesCalled) {
+      var afterCalled = 0;
+      var after = _.after(afterAmount, function() {
+        afterCalled++;
+      });
+      while (timesCalled--) after();
+      return afterCalled;
+    };
+
+    equal(testAfter(5, 5), 1, "after(N) should fire after being called N times");
+    equal(testAfter(5, 4), 0, "after(N) should not fire unless called N times");
+    equal(testAfter(0, 0), 1, "after(0) should fire immediately");
+  });
+
+});
diff --git a/underscore/test/index.html b/underscore/test/index.html
new file mode 100644
index 0000000..ea7a136
--- /dev/null
+++ b/underscore/test/index.html
@@ -0,0 +1,44 @@
+
+
+
+  Underscore Test Suite
+  
+  
+  
+  
+  
+
+  
+  
+  
+  
+  
+  
+  
+
+
+  

+  

+    

+      

+      

+    

+  

+  

+  
Underscore Speed Suite

+  

+    A representative sample of the functions are benchmarked here, to provide
+    a sense of how fast they might run in different browsers.
+    Each iteration runs on an array of 1000 elements.


+    For example, the 'intersection' test measures the number of times you can
+    find the intersection of two thousand-element arrays in one second.
+  

+  

+  
+
+
diff --git a/underscore/test/objects.js b/underscore/test/objects.js
new file mode 100644
index 0000000..22949c3
--- /dev/null
+++ b/underscore/test/objects.js
@@ -0,0 +1,548 @@
+$(document).ready(function() {
+
+  module("Objects");
+
+  test("keys", function() {
+    equal(_.keys({one : 1, two : 2}).join(', '), 'one, two', 'can extract the keys from an object');
+    // the test above is not safe because it relies on for-in enumeration order
+    var a = []; a[1] = 0;
+    equal(_.keys(a).join(', '), '1', 'is not fooled by sparse arrays; see issue #95');
+    raises(function() { _.keys(null); }, TypeError, 'throws an error for `null` values');
+    raises(function() { _.keys(void 0); }, TypeError, 'throws an error for `undefined` values');
+    raises(function() { _.keys(1); }, TypeError, 'throws an error for number primitives');
+    raises(function() { _.keys('a'); }, TypeError, 'throws an error for string primitives');
+    raises(function() { _.keys(true); }, TypeError, 'throws an error for boolean primitives');
+  });
+
+  test("values", function() {
+    equal(_.values({one: 1, two: 2}).join(', '), '1, 2', 'can extract the values from an object');
+    equal(_.values({one: 1, two: 2, length: 3}).join(', '), '1, 2, 3', '... even when one of them is "length"');
+  });
+
+  test("pairs", function() {
+    deepEqual(_.pairs({one: 1, two: 2}), [['one', 1], ['two', 2]], 'can convert an object into pairs');
+    deepEqual(_.pairs({one: 1, two: 2, length: 3}), [['one', 1], ['two', 2], ['length', 3]], '... even when one of them is "length"');
+  });
+
+  test("invert", function() {
+    var obj = {first: 'Moe', second: 'Larry', third: 'Curly'};
+    equal(_.keys(_.invert(obj)).join(' '), 'Moe Larry Curly', 'can invert an object');
+    ok(_.isEqual(_.invert(_.invert(obj)), obj), 'two inverts gets you back where you started');
+
+    var obj = {length: 3};
+    ok(_.invert(obj)['3'] == 'length', 'can invert an object with "length"')
+  });
+
+  test("functions", function() {
+    var obj = {a : 'dash', b : _.map, c : (/yo/), d : _.reduce};
+    ok(_.isEqual(['b', 'd'], _.functions(obj)), 'can grab the function names of any passed-in object');
+
+    var Animal = function(){};
+    Animal.prototype.run = function(){};
+    equal(_.functions(new Animal).join(''), 'run', 'also looks up functions on the prototype');
+  });
+
+  test("extend", function() {
+    var result;
+    equal(_.extend({}, {a:'b'}).a, 'b', 'can extend an object with the attributes of another');
+    equal(_.extend({a:'x'}, {a:'b'}).a, 'b', 'properties in source override destination');
+    equal(_.extend({x:'x'}, {a:'b'}).x, 'x', 'properties not in source dont get overriden');
+    result = _.extend({x:'x'}, {a:'a'}, {b:'b'});
+    ok(_.isEqual(result, {x:'x', a:'a', b:'b'}), 'can extend from multiple source objects');
+    result = _.extend({x:'x'}, {a:'a', x:2}, {a:'b'});
+    ok(_.isEqual(result, {x:2, a:'b'}), 'extending from multiple source objects last property trumps');
+    result = _.extend({}, {a: void 0, b: null});
+    equal(_.keys(result).join(''), 'ab', 'extend does not copy undefined values');
+  });
+
+  test("pick", function() {
+    var result;
+    result = _.pick({a:1, b:2, c:3}, 'a', 'c');
+    ok(_.isEqual(result, {a:1, c:3}), 'can restrict properties to those named');
+    result = _.pick({a:1, b:2, c:3}, ['b', 'c']);
+    ok(_.isEqual(result, {b:2, c:3}), 'can restrict properties to those named in an array');
+    result = _.pick({a:1, b:2, c:3}, ['a'], 'b');
+    ok(_.isEqual(result, {a:1, b:2}), 'can restrict properties to those named in mixed args');
+
+    var Obj = function(){};
+    Obj.prototype = {a: 1, b: 2, c: 3};
+    ok(_.isEqual(_.pick(new Obj, 'a', 'c'), {a:1, c: 3}), 'include prototype props');
+  });
+
+  test("omit", function() {
+    var result;
+    result = _.omit({a:1, b:2, c:3}, 'b');
+    ok(_.isEqual(result, {a:1, c:3}), 'can omit a single named property');
+    result = _.omit({a:1, b:2, c:3}, 'a', 'c');
+    ok(_.isEqual(result, {b:2}), 'can omit several named properties');
+    result = _.omit({a:1, b:2, c:3}, ['b', 'c']);
+    ok(_.isEqual(result, {a:1}), 'can omit properties named in an array');
+
+    var Obj = function(){};
+    Obj.prototype = {a: 1, b: 2, c: 3};
+    ok(_.isEqual(_.omit(new Obj, 'b'), {a:1, c: 3}), 'include prototype props');
+  });
+
+  test("defaults", function() {
+    var result;
+    var options = {zero: 0, one: 1, empty: "", nan: NaN, string: "string"};
+
+    _.defaults(options, {zero: 1, one: 10, twenty: 20});
+    equal(options.zero, 0, 'value exists');
+    equal(options.one, 1, 'value exists');
+    equal(options.twenty, 20, 'default applied');
+
+    _.defaults(options, {empty: "full"}, {nan: "nan"}, {word: "word"}, {word: "dog"});
+    equal(options.empty, "", 'value exists');
+    ok(_.isNaN(options.nan), "NaN isn't overridden");
+    equal(options.word, "word", 'new value is added, first one wins');
+  });
+
+  test("clone", function() {
+    var moe = {name : 'moe', lucky : [13, 27, 34]};
+    var clone = _.clone(moe);
+    equal(clone.name, 'moe', 'the clone as the attributes of the original');
+
+    clone.name = 'curly';
+    ok(clone.name == 'curly' && moe.name == 'moe', 'clones can change shallow attributes without affecting the original');
+
+    clone.lucky.push(101);
+    equal(_.last(moe.lucky), 101, 'changes to deep attributes are shared with the original');
+
+    equal(_.clone(undefined), void 0, 'non objects should not be changed by clone');
+    equal(_.clone(1), 1, 'non objects should not be changed by clone');
+    equal(_.clone(null), null, 'non objects should not be changed by clone');
+  });
+
+  test("isEqual", function() {
+    function First() {
+      this.value = 1;
+    }
+    First.prototype.value = 1;
+    function Second() {
+      this.value = 1;
+    }
+    Second.prototype.value = 2;
+
+    // Basic equality and identity comparisons.
+    ok(_.isEqual(null, null), "`null` is equal to `null`");
+    ok(_.isEqual(), "`undefined` is equal to `undefined`");
+
+    ok(!_.isEqual(0, -0), "`0` is not equal to `-0`");
+    ok(!_.isEqual(-0, 0), "Commutative equality is implemented for `0` and `-0`");
+    ok(!_.isEqual(null, undefined), "`null` is not equal to `undefined`");
+    ok(!_.isEqual(undefined, null), "Commutative equality is implemented for `null` and `undefined`");
+
+    // String object and primitive comparisons.
+    ok(_.isEqual("Curly", "Curly"), "Identical string primitives are equal");
+    ok(_.isEqual(new String("Curly"), new String("Curly")), "String objects with identical primitive values are equal");
+    ok(_.isEqual(new String("Curly"), "Curly"), "String primitives and their corresponding object wrappers are equal");
+    ok(_.isEqual("Curly", new String("Curly")), "Commutative equality is implemented for string objects and primitives");
+
+    ok(!_.isEqual("Curly", "Larry"), "String primitives with different values are not equal");
+    ok(!_.isEqual(new String("Curly"), new String("Larry")), "String objects with different primitive values are not equal");
+    ok(!_.isEqual(new String("Curly"), {toString: function(){ return "Curly"; }}), "String objects and objects with a custom `toString` method are not equal");
+
+    // Number object and primitive comparisons.
+    ok(_.isEqual(75, 75), "Identical number primitives are equal");
+    ok(_.isEqual(new Number(75), new Number(75)), "Number objects with identical primitive values are equal");
+    ok(_.isEqual(75, new Number(75)), "Number primitives and their corresponding object wrappers are equal");
+    ok(_.isEqual(new Number(75), 75), "Commutative equality is implemented for number objects and primitives");
+    ok(!_.isEqual(new Number(0), -0), "`new Number(0)` and `-0` are not equal");
+    ok(!_.isEqual(0, new Number(-0)), "Commutative equality is implemented for `new Number(0)` and `-0`");
+
+    ok(!_.isEqual(new Number(75), new Number(63)), "Number objects with different primitive values are not equal");
+    ok(!_.isEqual(new Number(63), {valueOf: function(){ return 63; }}), "Number objects and objects with a `valueOf` method are not equal");
+
+    // Comparisons involving `NaN`.
+    ok(_.isEqual(NaN, NaN), "`NaN` is equal to `NaN`");
+    ok(!_.isEqual(61, NaN), "A number primitive is not equal to `NaN`");
+    ok(!_.isEqual(new Number(79), NaN), "A number object is not equal to `NaN`");
+    ok(!_.isEqual(Infinity, NaN), "`Infinity` is not equal to `NaN`");
+
+    // Boolean object and primitive comparisons.
+    ok(_.isEqual(true, true), "Identical boolean primitives are equal");
+    ok(_.isEqual(new Boolean, new Boolean), "Boolean objects with identical primitive values are equal");
+    ok(_.isEqual(true, new Boolean(true)), "Boolean primitives and their corresponding object wrappers are equal");
+    ok(_.isEqual(new Boolean(true), true), "Commutative equality is implemented for booleans");
+    ok(!_.isEqual(new Boolean(true), new Boolean), "Boolean objects with different primitive values are not equal");
+
+    // Common type coercions.
+    ok(!_.isEqual(true, new Boolean(false)), "Boolean objects are not equal to the boolean primitive `true`");
+    ok(!_.isEqual("75", 75), "String and number primitives with like values are not equal");
+    ok(!_.isEqual(new Number(63), new String(63)), "String and number objects with like values are not equal");
+    ok(!_.isEqual(75, "75"), "Commutative equality is implemented for like string and number values");
+    ok(!_.isEqual(0, ""), "Number and string primitives with like values are not equal");
+    ok(!_.isEqual(1, true), "Number and boolean primitives with like values are not equal");
+    ok(!_.isEqual(new Boolean(false), new Number(0)), "Boolean and number objects with like values are not equal");
+    ok(!_.isEqual(false, new String("")), "Boolean primitives and string objects with like values are not equal");
+    ok(!_.isEqual(12564504e5, new Date(2009, 9, 25)), "Dates and their corresponding numeric primitive values are not equal");
+
+    // Dates.
+    ok(_.isEqual(new Date(2009, 9, 25), new Date(2009, 9, 25)), "Date objects referencing identical times are equal");
+    ok(!_.isEqual(new Date(2009, 9, 25), new Date(2009, 11, 13)), "Date objects referencing different times are not equal");
+    ok(!_.isEqual(new Date(2009, 11, 13), {
+      getTime: function(){
+        return 12606876e5;
+      }
+    }), "Date objects and objects with a `getTime` method are not equal");
+    ok(!_.isEqual(new Date("Curly"), new Date("Curly")), "Invalid dates are not equal");
+
+    // Functions.
+    ok(!_.isEqual(First, Second), "Different functions with identical bodies and source code representations are not equal");
+
+    // RegExps.
+    ok(_.isEqual(/(?:)/gim, /(?:)/gim), "RegExps with equivalent patterns and flags are equal");
+    ok(!_.isEqual(/(?:)/g, /(?:)/gi), "RegExps with equivalent patterns and different flags are not equal");
+    ok(!_.isEqual(/Moe/gim, /Curly/gim), "RegExps with different patterns and equivalent flags are not equal");
+    ok(!_.isEqual(/(?:)/gi, /(?:)/g), "Commutative equality is implemented for RegExps");
+    ok(!_.isEqual(/Curly/g, {source: "Larry", global: true, ignoreCase: false, multiline: false}), "RegExps and RegExp-like objects are not equal");
+
+    // Empty arrays, array-like objects, and object literals.
+    ok(_.isEqual({}, {}), "Empty object literals are equal");
+    ok(_.isEqual([], []), "Empty array literals are equal");
+    ok(_.isEqual([{}], [{}]), "Empty nested arrays and objects are equal");
+    ok(!_.isEqual({length: 0}, []), "Array-like objects and arrays are not equal.");
+    ok(!_.isEqual([], {length: 0}), "Commutative equality is implemented for array-like objects");
+
+    ok(!_.isEqual({}, []), "Object literals and array literals are not equal");
+    ok(!_.isEqual([], {}), "Commutative equality is implemented for objects and arrays");
+
+    // Arrays with primitive and object values.
+    ok(_.isEqual([1, "Larry", true], [1, "Larry", true]), "Arrays containing identical primitives are equal");
+    ok(_.isEqual([(/Moe/g), new Date(2009, 9, 25)], [(/Moe/g), new Date(2009, 9, 25)]), "Arrays containing equivalent elements are equal");
+
+    // Multi-dimensional arrays.
+    var a = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+    var b = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+    ok(_.isEqual(a, b), "Arrays containing nested arrays and objects are recursively compared");
+
+    // Overwrite the methods defined in ES 5.1 section 15.4.4.
+    a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceRight = null;
+    b.join = b.pop = b.reverse = b.shift = b.slice = b.splice = b.concat = b.sort = b.unshift = null;
+
+    // Array elements and properties.
+    ok(_.isEqual(a, b), "Arrays containing equivalent elements and different non-numeric properties are equal");
+    a.push("White Rocks");
+    ok(!_.isEqual(a, b), "Arrays of different lengths are not equal");
+    a.push("East Boulder");
+    b.push("Gunbarrel Ranch", "Teller Farm");
+    ok(!_.isEqual(a, b), "Arrays of identical lengths containing different elements are not equal");
+
+    // Sparse arrays.
+    ok(_.isEqual(Array(3), Array(3)), "Sparse arrays of identical lengths are equal");
+    ok(!_.isEqual(Array(3), Array(6)), "Sparse arrays of different lengths are not equal when both are empty");
+
+    // Simple objects.
+    ok(_.isEqual({a: "Curly", b: 1, c: true}, {a: "Curly", b: 1, c: true}), "Objects containing identical primitives are equal");
+    ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, 13)}), "Objects containing equivalent members are equal");
+    ok(!_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), "Objects of identical sizes with different values are not equal");
+    ok(!_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), "Objects of identical sizes with different property names are not equal");
+    ok(!_.isEqual({a: 1, b: 2}, {a: 1}), "Objects of different sizes are not equal");
+    ok(!_.isEqual({a: 1}, {a: 1, b: 2}), "Commutative equality is implemented for objects");
+    ok(!_.isEqual({x: 1, y: undefined}, {x: 1, z: 2}), "Objects with identical keys and different values are not equivalent");
+
+    // `A` contains nested objects and arrays.
+    a = {
+      name: new String("Moe Howard"),
+      age: new Number(77),
+      stooge: true,
+      hobbies: ["acting"],
+      film: {
+        name: "Sing a Song of Six Pants",
+        release: new Date(1947, 9, 30),
+        stars: [new String("Larry Fine"), "Shemp Howard"],
+        minutes: new Number(16),
+        seconds: 54
+      }
+    };
+
+    // `B` contains equivalent nested objects and arrays.
+    b = {
+      name: new String("Moe Howard"),
+      age: new Number(77),
+      stooge: true,
+      hobbies: ["acting"],
+      film: {
+        name: "Sing a Song of Six Pants",
+        release: new Date(1947, 9, 30),
+        stars: [new String("Larry Fine"), "Shemp Howard"],
+        minutes: new Number(16),
+        seconds: 54
+      }
+    };
+    ok(_.isEqual(a, b), "Objects with nested equivalent members are recursively compared");
+
+    // Instances.
+    ok(_.isEqual(new First, new First), "Object instances are equal");
+    ok(!_.isEqual(new First, new Second), "Objects with different constructors and identical own properties are not equal");
+    ok(!_.isEqual({value: 1}, new First), "Object instances and objects sharing equivalent properties are not equal");
+    ok(!_.isEqual({value: 2}, new Second), "The prototype chain of objects should not be examined");
+
+    // Circular Arrays.
+    (a = []).push(a);
+    (b = []).push(b);
+    ok(_.isEqual(a, b), "Arrays containing circular references are equal");
+    a.push(new String("Larry"));
+    b.push(new String("Larry"));
+    ok(_.isEqual(a, b), "Arrays containing circular references and equivalent properties are equal");
+    a.push("Shemp");
+    b.push("Curly");
+    ok(!_.isEqual(a, b), "Arrays containing circular references and different properties are not equal");
+
+    // More circular arrays #767.
+    a = ["everything is checked but", "this", "is not"];
+    a[1] = a;
+    b = ["everything is checked but", ["this", "array"], "is not"];
+    ok(!_.isEqual(a, b), "Comparison of circular references with non-circular references are not equal");
+
+    // Circular Objects.
+    a = {abc: null};
+    b = {abc: null};
+    a.abc = a;
+    b.abc = b;
+    ok(_.isEqual(a, b), "Objects containing circular references are equal");
+    a.def = 75;
+    b.def = 75;
+    ok(_.isEqual(a, b), "Objects containing circular references and equivalent properties are equal");
+    a.def = new Number(75);
+    b.def = new Number(63);
+    ok(!_.isEqual(a, b), "Objects containing circular references and different properties are not equal");
+
+    // More circular objects #767.
+    a = {everything: "is checked", but: "this", is: "not"};
+    a.but = a;
+    b = {everything: "is checked", but: {that:"object"}, is: "not"};
+    ok(!_.isEqual(a, b), "Comparison of circular references with non-circular object references are not equal");
+
+    // Cyclic Structures.
+    a = [{abc: null}];
+    b = [{abc: null}];
+    (a[0].abc = a).push(a);
+    (b[0].abc = b).push(b);
+    ok(_.isEqual(a, b), "Cyclic structures are equal");
+    a[0].def = "Larry";
+    b[0].def = "Larry";
+    ok(_.isEqual(a, b), "Cyclic structures containing equivalent properties are equal");
+    a[0].def = new String("Larry");
+    b[0].def = new String("Curly");
+    ok(!_.isEqual(a, b), "Cyclic structures containing different properties are not equal");
+
+    // Complex Circular References.
+    a = {foo: {b: {foo: {c: {foo: null}}}}};
+    b = {foo: {b: {foo: {c: {foo: null}}}}};
+    a.foo.b.foo.c.foo = a;
+    b.foo.b.foo.c.foo = b;
+    ok(_.isEqual(a, b), "Cyclic structures with nested and identically-named properties are equal");
+
+    // Chaining.
+    ok(!_.isEqual(_({x: 1, y: undefined}).chain(), _({x: 1, z: 2}).chain()), 'Chained objects containing different values are not equal');
+    equal(_({x: 1, y: 2}).chain().isEqual(_({x: 1, y: 2}).chain()).value(), true, '`isEqual` can be chained');
+
+    // Custom `isEqual` methods.
+    var isEqualObj = {isEqual: function (o) { return o.isEqual == this.isEqual; }, unique: {}};
+    var isEqualObjClone = {isEqual: isEqualObj.isEqual, unique: {}};
+
+    ok(_.isEqual(isEqualObj, isEqualObjClone), 'Both objects implement identical `isEqual` methods');
+    ok(_.isEqual(isEqualObjClone, isEqualObj), 'Commutative equality is implemented for objects with custom `isEqual` methods');
+    ok(!_.isEqual(isEqualObj, {}), 'Objects that do not implement equivalent `isEqual` methods are not equal');
+    ok(!_.isEqual({}, isEqualObj), 'Commutative equality is implemented for objects with different `isEqual` methods');
+
+    // Objects from another frame.
+    ok(_.isEqual({}, iObject));
+  });
+
+  test("isEmpty", function() {
+    ok(!_([1]).isEmpty(), '[1] is not empty');
+    ok(_.isEmpty([]), '[] is empty');
+    ok(!_.isEmpty({one : 1}), '{one : 1} is not empty');
+    ok(_.isEmpty({}), '{} is empty');
+    ok(_.isEmpty(new RegExp('')), 'objects with prototype properties are empty');
+    ok(_.isEmpty(null), 'null is empty');
+    ok(_.isEmpty(), 'undefined is empty');
+    ok(_.isEmpty(''), 'the empty string is empty');
+    ok(!_.isEmpty('moe'), 'but other strings are not');
+
+    var obj = {one : 1};
+    delete obj.one;
+    ok(_.isEmpty(obj), 'deleting all the keys from an object empties it');
+  });
+
+  // Setup remote variables for iFrame tests.
+  var iframe = document.createElement('iframe');
+  jQuery(iframe).appendTo(document.body);
+  var iDoc = iframe.contentDocument || iframe.contentWindow.document;
+  iDoc.write(
+    ""
+  );
+  iDoc.close();
+
+  test("isElement", function() {
+    ok(!_.isElement('div'), 'strings are not dom elements');
+    ok(_.isElement($('html')[0]), 'the html tag is a DOM element');
+    ok(_.isElement(iElement), 'even from another frame');
+  });
+
+  test("isArguments", function() {
+    var args = (function(){ return arguments; })(1, 2, 3);
+    ok(!_.isArguments('string'), 'a string is not an arguments object');
+    ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
+    ok(_.isArguments(args), 'but the arguments object is an arguments object');
+    ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
+    ok(!_.isArguments([1,2,3]), 'and not vanilla arrays.');
+    ok(_.isArguments(iArguments), 'even from another frame');
+  });
+
+  test("isObject", function() {
+    ok(_.isObject(arguments), 'the arguments object is object');
+    ok(_.isObject([1, 2, 3]), 'and arrays');
+    ok(_.isObject($('html')[0]), 'and DOM element');
+    ok(_.isObject(iElement), 'even from another frame');
+    ok(_.isObject(function () {}), 'and functions');
+    ok(_.isObject(iFunction), 'even from another frame');
+    ok(!_.isObject(null), 'but not null');
+    ok(!_.isObject(undefined), 'and not undefined');
+    ok(!_.isObject('string'), 'and not string');
+    ok(!_.isObject(12), 'and not number');
+    ok(!_.isObject(true), 'and not boolean');
+    ok(_.isObject(new String('string')), 'but new String()');
+  });
+
+  test("isArray", function() {
+    ok(!_.isArray(arguments), 'the arguments object is not an array');
+    ok(_.isArray([1, 2, 3]), 'but arrays are');
+    ok(_.isArray(iArray), 'even from another frame');
+  });
+
+  test("isString", function() {
+    ok(!_.isString(document.body), 'the document body is not a string');
+    ok(_.isString([1, 2, 3].join(', ')), 'but strings are');
+    ok(_.isString(iString), 'even from another frame');
+  });
+
+  test("isNumber", function() {
+    ok(!_.isNumber('string'), 'a string is not a number');
+    ok(!_.isNumber(arguments), 'the arguments object is not a number');
+    ok(!_.isNumber(undefined), 'undefined is not a number');
+    ok(_.isNumber(3 * 4 - 7 / 10), 'but numbers are');
+    ok(_.isNumber(NaN), 'NaN *is* a number');
+    ok(_.isNumber(Infinity), 'Infinity is a number');
+    ok(_.isNumber(iNumber), 'even from another frame');
+    ok(!_.isNumber('1'), 'numeric strings are not numbers');
+  });
+
+  test("isBoolean", function() {
+    ok(!_.isBoolean(2), 'a number is not a boolean');
+    ok(!_.isBoolean("string"), 'a string is not a boolean');
+    ok(!_.isBoolean("false"), 'the string "false" is not a boolean');
+    ok(!_.isBoolean("true"), 'the string "true" is not a boolean');
+    ok(!_.isBoolean(arguments), 'the arguments object is not a boolean');
+    ok(!_.isBoolean(undefined), 'undefined is not a boolean');
+    ok(!_.isBoolean(NaN), 'NaN is not a boolean');
+    ok(!_.isBoolean(null), 'null is not a boolean');
+    ok(_.isBoolean(true), 'but true is');
+    ok(_.isBoolean(false), 'and so is false');
+    ok(_.isBoolean(iBoolean), 'even from another frame');
+  });
+
+  test("isFunction", function() {
+    ok(!_.isFunction([1, 2, 3]), 'arrays are not functions');
+    ok(!_.isFunction('moe'), 'strings are not functions');
+    ok(_.isFunction(_.isFunction), 'but functions are');
+    ok(_.isFunction(iFunction), 'even from another frame');
+  });
+
+  test("isDate", function() {
+    ok(!_.isDate(100), 'numbers are not dates');
+    ok(!_.isDate({}), 'objects are not dates');
+    ok(_.isDate(new Date()), 'but dates are');
+    ok(_.isDate(iDate), 'even from another frame');
+  });
+
+  test("isRegExp", function() {
+    ok(!_.isRegExp(_.identity), 'functions are not RegExps');
+    ok(_.isRegExp(/identity/), 'but RegExps are');
+    ok(_.isRegExp(iRegExp), 'even from another frame');
+  });
+
+  test("isFinite", function() {
+    ok(!_.isFinite(undefined), 'undefined is not Finite');
+    ok(!_.isFinite(null), 'null is not Finite');
+    ok(!_.isFinite(NaN), 'NaN is not Finite');
+    ok(!_.isFinite(Infinity), 'Infinity is not Finite');
+    ok(!_.isFinite(-Infinity), '-Infinity is not Finite');
+    ok(!_.isFinite('12'), 'Strings are not numbers');
+    var obj = new Number(5);
+    ok(_.isFinite(obj), 'Number instances can be finite');
+    ok(_.isFinite(0), '0 is Finite');
+    ok(_.isFinite(123), 'Ints are Finite');
+    ok(_.isFinite(-12.44), 'Floats are Finite');
+  });
+
+  test("isNaN", function() {
+    ok(!_.isNaN(undefined), 'undefined is not NaN');
+    ok(!_.isNaN(null), 'null is not NaN');
+    ok(!_.isNaN(0), '0 is not NaN');
+    ok(_.isNaN(NaN), 'but NaN is');
+    ok(_.isNaN(iNaN), 'even from another frame');
+    ok(_.isNaN(new Number(NaN)), 'wrapped NaN is still NaN');
+  });
+
+  test("isNull", function() {
+    ok(!_.isNull(undefined), 'undefined is not null');
+    ok(!_.isNull(NaN), 'NaN is not null');
+    ok(_.isNull(null), 'but null is');
+    ok(_.isNull(iNull), 'even from another frame');
+  });
+
+  test("isUndefined", function() {
+    ok(!_.isUndefined(1), 'numbers are defined');
+    ok(!_.isUndefined(null), 'null is defined');
+    ok(!_.isUndefined(false), 'false is defined');
+    ok(!_.isUndefined(NaN), 'NaN is defined');
+    ok(_.isUndefined(), 'nothing is undefined');
+    ok(_.isUndefined(undefined), 'undefined is undefined');
+    ok(_.isUndefined(iUndefined), 'even from another frame');
+  });
+
+  if (window.ActiveXObject) {
+    test("IE host objects", function() {
+      var xml = new ActiveXObject("Msxml2.DOMDocument.3.0");
+      ok(!_.isNumber(xml));
+      ok(!_.isBoolean(xml));
+      ok(!_.isNaN(xml));
+      ok(!_.isFunction(xml));
+      ok(!_.isNull(xml));
+      ok(!_.isUndefined(xml));
+    });
+  }
+
+  test("tap", function() {
+    var intercepted = null;
+    var interceptor = function(obj) { intercepted = obj; };
+    var returned = _.tap(1, interceptor);
+    equal(intercepted, 1, "passes tapped object to interceptor");
+    equal(returned, 1, "returns tapped object");
+
+    returned = _([1,2,3]).chain().
+      map(function(n){ return n * 2; }).
+      max().
+      tap(interceptor).
+      value();
+    ok(returned == 6 && intercepted == 6, 'can use tapped objects in a chain');
+  });
+});
diff --git a/underscore/test/speed.js b/underscore/test/speed.js
new file mode 100644
index 0000000..05e3f2a
--- /dev/null
+++ b/underscore/test/speed.js
@@ -0,0 +1,75 @@
+(function() {
+
+  var numbers = [];
+  for (var i=0; i<1000; i++) numbers.push(i);
+  var objects = _.map(numbers, function(n){ return {num : n}; });
+  var randomized = _.sortBy(numbers, function(){ return Math.random(); });
+  var deep = _.map(_.range(100), function() { return _.range(1000); });
+
+  JSLitmus.test('_.each()', function() {
+    var timesTwo = [];
+    _.each(numbers, function(num){ timesTwo.push(num * 2); });
+    return timesTwo;
+  });
+
+  JSLitmus.test('_(list).each()', function() {
+    var timesTwo = [];
+    _(numbers).each(function(num){ timesTwo.push(num * 2); });
+    return timesTwo;
+  });
+
+  JSLitmus.test('jQuery.each()', function() {
+    var timesTwo = [];
+    jQuery.each(numbers, function(){ timesTwo.push(this * 2); });
+    return timesTwo;
+  });
+
+  JSLitmus.test('_.map()', function() {
+    return _.map(objects, function(obj){ return obj.num; });
+  });
+
+  JSLitmus.test('jQuery.map()', function() {
+    return jQuery.map(objects, function(obj){ return obj.num; });
+  });
+
+  JSLitmus.test('_.pluck()', function() {
+    return _.pluck(objects, 'num');
+  });
+
+  JSLitmus.test('_.uniq()', function() {
+    return _.uniq(randomized);
+  });
+
+  JSLitmus.test('_.uniq() (sorted)', function() {
+    return _.uniq(numbers, true);
+  });
+
+  JSLitmus.test('_.sortBy()', function() {
+    return _.sortBy(numbers, function(num){ return -num; });
+  });
+
+  JSLitmus.test('_.isEqual()', function() {
+    return _.isEqual(numbers, randomized);
+  });
+
+  JSLitmus.test('_.keys()', function() {
+    return _.keys(objects);
+  });
+
+  JSLitmus.test('_.values()', function() {
+    return _.values(objects);
+  });
+
+  JSLitmus.test('_.intersection()', function() {
+    return _.intersection(numbers, randomized);
+  });
+
+  JSLitmus.test('_.range()', function() {
+    return _.range(1000);
+  });
+
+  JSLitmus.test('_.flatten()', function() {
+    return _.flatten(deep);
+  });
+
+})();
diff --git a/underscore/test/utility.js b/underscore/test/utility.js
new file mode 100644
index 0000000..c9be20a
--- /dev/null
+++ b/underscore/test/utility.js
@@ -0,0 +1,249 @@
+$(document).ready(function() {
+
+  var templateSettings;
+
+  module("Utility", {
+
+    setup: function() {
+      templateSettings = _.clone(_.templateSettings);
+    },
+
+    teardown: function() {
+      _.templateSettings = templateSettings;
+    }
+
+  });
+
+  test("#750 - Return _ instance.", 2, function() {
+    var instance = _([]);
+    ok(_(instance) === instance);
+    ok(new _(instance) === instance);
+  });
+
+  test("identity", function() {
+    var moe = {name : 'moe'};
+    equal(_.identity(moe), moe, 'moe is the same as his identity');
+  });
+
+  test("uniqueId", function() {
+    var ids = [], i = 0;
+    while(i++ < 100) ids.push(_.uniqueId());
+    equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
+  });
+
+  test("times", function() {
+    var vals = [];
+    _.times(3, function (i) { vals.push(i); });
+    ok(_.isEqual(vals, [0,1,2]), "is 0 indexed");
+    //
+    vals = [];
+    _(3).times(function (i) { vals.push(i); });
+    ok(_.isEqual(vals, [0,1,2]), "works as a wrapper");
+  });
+
+  test("mixin", function() {
+    _.mixin({
+      myReverse: function(string) {
+        return string.split('').reverse().join('');
+      }
+    });
+    equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
+    equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
+  });
+
+  test("_.escape", function() {
+    equal(_.escape("Curly & Moe"), "Curly & Moe");
+    equal(_.escape("Curly & Moe"), "Curly &amp; Moe");
+    equal(_.escape(null), '');
+  });
+
+  test("_.unescape", function() {
+    var string = "Curly & Moe";
+    equal(_.unescape("Curly & Moe"), string);
+    equal(_.unescape("Curly &amp; Moe"), "Curly & Moe");
+    equal(_.unescape(null), '');
+    equal(_.unescape(_.escape(string)), string);
+  });
+
+  test("template", function() {
+    var basicTemplate = _.template("<%= thing %> is gettin' on my noives!");
+    var result = basicTemplate({thing : 'This'});
+    equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
+
+    var sansSemicolonTemplate = _.template("A <% this %> B");
+    equal(sansSemicolonTemplate(), "A  B");
+
+    var backslashTemplate = _.template("<%= thing %> is \\ridanculous");
+    equal(backslashTemplate({thing: 'This'}), "This is \\ridanculous");
+
+    var escapeTemplate = _.template('<%= a ? "checked=\\"checked\\"" : "" %>');
+    equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
+
+    var fancyTemplate = _.template("
    <% \
+      for (key in people) { \
+    %>
  • <%= people[key] %>
    • <% } %>
");
+    result = fancyTemplate({people : {moe : "Moe", larry : "Larry", curly : "Curly"}});
+    equal(result, "
  • Moe
  • Larry
  • Curly
", 'can run arbitrary javascript in templates');
+
+    var escapedCharsInJavascriptTemplate = _.template("
    <% _.each(numbers.split('\\n'), function(item) { %>
  • <%= item %>
    • <% }) %>
");
+    result = escapedCharsInJavascriptTemplate({numbers: "one\ntwo\nthree\nfour"});
+    equal(result, "
  • one
  • two
  • three
  • four
", 'Can use escaped characters (e.g. \\n) in Javascript');
+
+    var namespaceCollisionTemplate = _.template("<%= pageCount %> <%= thumbnails[pageCount] %> <% _.each(thumbnails, function(p) { %>
\">
<% }); %>");
+    result = namespaceCollisionTemplate({
+      pageCount: 3,
+      thumbnails: {
+        1: "p1-thumbnail.gif",
+        2: "p2-thumbnail.gif",
+        3: "p3-thumbnail.gif"
+      }
+    });
+    equal(result, "3 p3-thumbnail.gif 
");
+
+    var noInterpolateTemplate = _.template("
Just some text. Hey, I know this is silly but it aids consistency.
");
+    result = noInterpolateTemplate();
+    equal(result, "
Just some text. Hey, I know this is silly but it aids consistency.
");
+
+    var quoteTemplate = _.template("It's its, not it's");
+    equal(quoteTemplate({}), "It's its, not it's");
+
+    var quoteInStatementAndBody = _.template("<%\
+      if(foo == 'bar'){ \
+    %>Statement quotes and 'quotes'.<% } %>");
+    equal(quoteInStatementAndBody({foo: "bar"}), "Statement quotes and 'quotes'.");
+
+    var withNewlinesAndTabs = _.template('This\n\t\tis: <%= x %>.\n\tok.\nend.');
+    equal(withNewlinesAndTabs({x: 'that'}), 'This\n\t\tis: that.\n\tok.\nend.');
+
+    var template = _.template("<%- value %>");
+    var result = template({value: "