Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

various fixes

  • Loading branch information...
commit 5a8c6c09c53869a22b758cbe7a0dc30a4b8c3f69 1 parent 769654e
@crcn authored
View
26 examples/parse-ex.js
@@ -0,0 +1,26 @@
+var celeri = require("../");
+
+
+//an option with info for the help menu
+celeri.option({
+ command: 'hello :person',
+ description: 'Prints "hello [person]!"',
+ optional: {
+ '--age': 'The person\'s age',
+ '--gender': 'The person\'s gender'
+ }
+}, function(data) {
+
+ console.log("Hello %s!", data.person);
+
+ if(data.age) console.log("%s is %d years old.", data.person, data.age);
+ if(data.gender) console.log("%s is a %s.", data.person, data.gender);
+
+});
+
+
+celeri.parse(process.argv, function(e, cmd) {
+ if(e) throw e;
+
+ if(cmd.command.length) celeri.open();
+});
View
1  node_modules/underscore/.gitignore
@@ -0,0 +1 @@
+raw
View
3  node_modules/underscore/.npmignore
@@ -0,0 +1,3 @@
+test/
+Rakefile
+docs/
View
22 node_modules/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.
View
19 node_modules/underscore/README
@@ -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://documentcloud.github.com/underscore/
+
+Many thanks to our contributors:
+https://github.com/documentcloud/underscore/contributors
View
1,919 node_modules/underscore/index.html
@@ -0,0 +1,1919 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+ <meta http-equiv="X-UA-Compatible" content="chrome=1">
+ <title>Underscore.js</title>
+ <style>
+ body {
+ font-size: 14px;
+ line-height: 22px;
+ background: #f4f4f4 url(docs/images/background.png);
+ color: #000;
+ font-family: Helvetica Neue, Helvetica, Arial;
+ }
+ .interface {
+ font-family: "Lucida Grande", "Lucida Sans Unicode", Helvetica, Arial, sans-serif !important;
+ }
+ div#sidebar {
+ background: #fff;
+ position: fixed;
+ top: 0; left: 0; bottom: 0;
+ width: 200px;
+ overflow-y: auto;
+ overflow-x: hidden;
+ padding: 15px 0 30px 30px;
+ border-right: 1px solid #bbb;
+ box-shadow: 0 0 20px #ccc; -webkit-box-shadow: 0 0 20px #ccc; -moz-box-shadow: 0 0 20px #ccc;
+ }
+ a.toc_title, a.toc_title:visited {
+ display: block;
+ color: black;
+ font-weight: bold;
+ margin-top: 15px;
+ }
+ a.toc_title:hover {
+ text-decoration: underline;
+ }
+ #sidebar .version {
+ font-size: 10px;
+ font-weight: normal;
+ }
+ ul.toc_section {
+ font-size: 11px;
+ line-height: 14px;
+ margin: 5px 0 0 0;
+ padding-left: 0px;
+ list-style-type: none;
+ font-family: Lucida Grande;
+ }
+ .toc_section li {
+ cursor: pointer;
+ margin: 0 0 3px 0;
+ }
+ .toc_section li a {
+ text-decoration: none;
+ color: black;
+ }
+ .toc_section li a:hover {
+ text-decoration: underline;
+ }
+ div.container {
+ width: 550px;
+ margin: 40px 0 50px 260px;
+ }
+ p {
+ margin: 20px 0;
+ width: 550px;
+ }
+ a, a:visited {
+ color: #444;
+ }
+ a:active, a:hover {
+ color: #000;
+ }
+ h1, h2, h3, h4, h5, h6 {
+ padding-top: 20px;
+ }
+ h2 {
+ font-size: 20px;
+ }
+ b.header {
+ font-size: 16px;
+ line-height: 30px;
+ }
+ span.alias {
+ font-size: 14px;
+ font-style: italic;
+ margin-left: 20px;
+ }
+ table, tr, td {
+ margin: 0; padding: 0;
+ }
+ td {
+ padding: 2px 12px 2px 0;
+ }
+ ul {
+ list-style-type: circle;
+ padding: 0 0 0 20px;
+ }
+ li {
+ width: 500px;
+ margin-bottom: 10px;
+ }
+ code, pre, tt {
+ font-family: Monaco, Consolas, "Lucida Console", monospace;
+ font-size: 12px;
+ line-height: 18px;
+ font-style: normal;
+ }
+ tt {
+ padding: 0px 3px;
+ background: #fff;
+ border: 1px solid #ddd;
+ zoom: 1;
+ }
+ code {
+ margin-left: 20px;
+ }
+ pre {
+ font-size: 12px;
+ padding: 2px 0 2px 15px;
+ border-left: 5px solid #bbb;
+ margin: 0px 0 30px;
+ }
+ </style>
+</head>
+<body>
+
+ <div id="sidebar" class="interface">
+
+ <a class="toc_title" href="#">
+ Underscore.js <span class="version">(1.2.4)</span>
+ </a>
+
+ <a class="toc_title" href="#">
+ Introduction
+ </a>
+
+ <a class="toc_title" href="#collections">
+ Collections
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#each">each</a></li>
+ <li>- <a href="#map">map</a></li>
+ <li>- <a href="#reduce">reduce</a></li>
+ <li>- <a href="#reduceRight">reduceRight</a></li>
+ <li>- <a href="#find">find</a></li>
+ <li>- <a href="#filter">filter</a></li>
+ <li>- <a href="#reject">reject</a></li>
+ <li>- <a href="#all">all</a></li>
+ <li>- <a href="#any">any</a></li>
+ <li>- <a href="#include">include</a></li>
+ <li>- <a href="#invoke">invoke</a></li>
+ <li>- <a href="#pluck">pluck</a></li>
+ <li>- <a href="#max">max</a></li>
+ <li>- <a href="#min">min</a></li>
+ <li>- <a href="#sortBy">sortBy</a></li>
+ <li>- <a href="#groupBy">groupBy</a></li>
+ <li>- <a href="#sortedIndex">sortedIndex</a></li>
+ <li>- <a href="#shuffle">shuffle</a></li>
+ <li>- <a href="#toArray">toArray</a></li>
+ <li>- <a href="#size">size</a></li>
+ </ul>
+
+ <a class="toc_title" href="#arrays">
+ Arrays
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#first">first</a></li>
+ <li>- <a href="#initial">initial</a></li>
+ <li>- <a href="#last">last</a></li>
+ <li>- <a href="#rest">rest</a></li>
+ <li>- <a href="#compact">compact</a></li>
+ <li>- <a href="#flatten">flatten</a></li>
+ <li>- <a href="#without">without</a></li>
+ <li>- <a href="#union">union</a></li>
+ <li>- <a href="#intersection">intersection</a></li>
+ <li>- <a href="#difference">difference</a></li>
+ <li>- <a href="#uniq">uniq</a></li>
+ <li>- <a href="#zip">zip</a></li>
+ <li>- <a href="#indexOf">indexOf</a></li>
+ <li>- <a href="#lastIndexOf">lastIndexOf</a></li>
+ <li>- <a href="#range">range</a></li>
+ </ul>
+
+ <a class="toc_title" href="#functions">
+ Functions
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#bind">bind</a></li>
+ <li>- <a href="#bindAll">bindAll</a></li>
+ <li>- <a href="#memoize">memoize</a></li>
+ <li>- <a href="#delay">delay</a></li>
+ <li>- <a href="#defer">defer</a></li>
+ <li>- <a href="#throttle">throttle</a></li>
+ <li>- <a href="#debounce">debounce</a></li>
+ <li>- <a href="#once">once</a></li>
+ <li>- <a href="#after">after</a></li>
+ <li>- <a href="#wrap">wrap</a></li>
+ <li>- <a href="#compose">compose</a></li>
+ </ul>
+
+ <a class="toc_title" href="#objects">
+ Objects
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#keys">keys</a></li>
+ <li>- <a href="#values">values</a></li>
+ <li>- <a href="#functions">functions</a></li>
+ <li>- <a href="#extend">extend</a></li>
+ <li>- <a href="#defaults">defaults</a></li>
+ <li>- <a href="#clone">clone</a></li>
+ <li>- <a href="#tap">tap</a></li>
+ <li>- <a href="#isEqual">isEqual</a></li>
+ <li>- <a href="#isEmpty">isEmpty</a></li>
+ <li>- <a href="#isElement">isElement</a></li>
+ <li>- <a href="#isArray">isArray</a></li>
+ <li>- <a href="#isArguments">isArguments</a></li>
+ <li>- <a href="#isFunction">isFunction</a></li>
+ <li>- <a href="#isString">isString</a></li>
+ <li>- <a href="#isNumber">isNumber</a></li>
+ <li>- <a href="#isBoolean">isBoolean</a></li>
+ <li>- <a href="#isDate">isDate</a></li>
+ <li>- <a href="#isRegExp">isRegExp</a></li>
+ <li>- <a href="#isNaN">isNaN</a></li>
+ <li>- <a href="#isNull">isNull</a></li>
+ <li>- <a href="#isUndefined">isUndefined</a></li>
+ </ul>
+
+ <a class="toc_title" href="#utility">
+ Utility
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#noConflict">noConflict</a></li>
+ <li>- <a href="#identity">identity</a></li>
+ <li>- <a href="#times">times</a></li>
+ <li>- <a href="#mixin">mixin</a></li>
+ <li>- <a href="#uniqueId">uniqueId</a></li>
+ <li>- <a href="#escape">escape</a></li>
+ <li>- <a href="#template">template</a></li>
+ </ul>
+
+ <a class="toc_title" href="#chaining">
+ Chaining
+ </a>
+ <ul class="toc_section">
+ <li>- <a href="#chain">chain</a></li>
+ <li>- <a href="#value">value</a></li>
+ </ul>
+
+ <a class="toc_title" href="#links">
+ Links
+ </a>
+
+ <a class="toc_title" href="#changelog">
+ Change Log
+ </a>
+
+ </div>
+
+ <div class="container">
+
+ <p id="introduction">
+ <img style="width: 396px; height: 69px;" src="docs/images/underscore.png" alt="Underscore.js" />
+ </p>
+
+ <p>
+ <a href="http://github.com/documentcloud/underscore/">Underscore</a> is a
+ utility-belt library for JavaScript that provides a lot of the
+ functional programming support that you would expect in
+ <a href="http://prototypejs.org/api">Prototype.js</a>
+ (or <a href="http://www.ruby-doc.org/core/classes/Enumerable.html">Ruby</a>),
+ but without extending any of the built-in JavaScript objects. It's the
+ tie to go along with <a href="http://docs.jquery.com">jQuery</a>'s tux,
+ and <a href="http://backbonejs.org">Backbone.js</a>'s suspenders.
+ </p>
+
+ <p>
+ Underscore provides 60-odd functions that support both the usual
+ functional suspects: <b>map</b>, <b>select</b>, <b>invoke</b> &mdash;
+ 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 <b>forEach</b>, <b>map</b>, <b>reduce</b>,
+ <b>filter</b>, <b>every</b>, <b>some</b> and <b>indexOf</b>.
+ </p>
+
+ <p>
+ A complete <a href="test/test.html">Test &amp; Benchmark Suite</a>
+ is included for your perusal.
+ </p>
+
+ <p>
+ You may also read through the <a href="docs/underscore.html">annotated source code</a>.
+ </p>
+
+ <p>
+ The project is
+ <a href="http://github.com/documentcloud/underscore/">hosted on GitHub</a>.
+ You can report bugs and discuss features on the
+ <a href="http://github.com/documentcloud/underscore/issues">issues page</a>,
+ on Freenode in the <tt>#documentcloud</tt> channel,
+ or send tweets to <a href="http://twitter.com/documentcloud">@documentcloud</a>.
+ </p>
+
+ <p>
+ <i>Underscore is an open-source component of <a href="http://documentcloud.org/">DocumentCloud</a>.</i>
+ </p>
+
+ <h2>Downloads <i style="padding-left: 12px; font-size:12px;">(Right-click, and use "Save As")</i></h2>
+
+ <table>
+ <tr>
+ <td><a href="underscore.js">Development Version (1.2.4)</a></td>
+ <td><i>34kb, Uncompressed with Comments</i></td>
+ </tr>
+ <tr>
+ <td><a href="underscore-min.js">Production Version (1.2.4)</a></td>
+ <td><i>&lt; 4kb, Minified and Gzipped</i></td>
+ </tr>
+ </table>
+
+ <div id="documentation">
+
+ <h2 id="collections">Collection Functions (Arrays or Objects)</h2>
+
+ <p id="each">
+ <b class="header">each</b><code>_.each(list, iterator, [context])</code>
+ <span class="alias">Alias: <b>forEach</b></span>
+ <br />
+ Iterates over a <b>list</b> of elements, yielding each in turn to an <b>iterator</b>
+ function. The <b>iterator</b> is bound to the <b>context</b> object, if one is
+ passed. Each invocation of <b>iterator</b> is called with three arguments:
+ <tt>(element, index, list)</tt>. If <b>list</b> is a JavaScript object, <b>iterator</b>'s
+ arguments will be <tt>(value, key, list)</tt>. Delegates to the native
+ <b>forEach</b> function if it exists.
+ </p>
+ <pre>
+_.each([1, 2, 3], function(num){ alert(num); });
+=&gt; alerts each number in turn...
+_.each({one : 1, two : 2, three : 3}, function(num, key){ alert(num); });
+=&gt; alerts each number in turn...</pre>
+
+ <p id="map">
+ <b class="header">map</b><code>_.map(list, iterator, [context])</code>
+ <br />
+ Produces a new array of values by mapping each value in <b>list</b>
+ through a transformation function (<b>iterator</b>). If the native <b>map</b> method
+ exists, it will be used instead. If <b>list</b> is a JavaScript object,
+ <b>iterator</b>'s arguments will be <tt>(value, key, list)</tt>.
+ </p>
+ <pre>
+_.map([1, 2, 3], function(num){ return num * 3; });
+=&gt; [3, 6, 9]
+_.map({one : 1, two : 2, three : 3}, function(num, key){ return num * 3; });
+=&gt; [3, 6, 9]</pre>
+
+ <p id="reduce">
+ <b class="header">reduce</b><code>_.reduce(list, iterator, memo, [context])</code>
+ <span class="alias">Aliases: <b>inject, foldl</b></span>
+ <br />
+ Also known as <b>inject</b> and <b>foldl</b>, <b>reduce</b> boils down a
+ <b>list</b> of values into a single value. <b>Memo</b> is the initial state
+ of the reduction, and each successive step of it should be returned by
+ <b>iterator</b>.
+ </p>
+ <pre>
+var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);
+=&gt; 6
+</pre>
+
+ <p id="reduceRight">
+ <b class="header">reduceRight</b><code>_.reduceRight(list, iterator, memo, [context])</code>
+ <span class="alias">Alias: <b>foldr</b></span>
+ <br />
+ The right-associative version of <b>reduce</b>. Delegates to the
+ JavaScript 1.8 version of <b>reduceRight</b>, if it exists. <b>Foldr</b>
+ is not as useful in JavaScript as it would be in a language with lazy
+ evaluation.
+ </p>
+ <pre>
+var list = [[0, 1], [2, 3], [4, 5]];
+var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+=&gt; [4, 5, 2, 3, 0, 1]
+</pre>
+
+ <p id="find">
+ <b class="header">find</b><code>_.find(list, iterator, [context])</code>
+ <span class="alias">Alias: <b>detect</b></span>
+ <br />
+ Looks through each value in the <b>list</b>, returning the first one that
+ passes a truth test (<b>iterator</b>). The function returns as
+ soon as it finds an acceptable element, and doesn't traverse the
+ entire list.
+ </p>
+ <pre>
+var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=&gt; 2
+</pre>
+
+ <p id="filter">
+ <b class="header">filter</b><code>_.filter(list, iterator, [context])</code>
+ <span class="alias">Alias: <b>select</b></span>
+ <br />
+ Looks through each value in the <b>list</b>, returning an array of all
+ the values that pass a truth test (<b>iterator</b>). Delegates to the
+ native <b>filter</b> method, if it exists.
+ </p>
+ <pre>
+var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=&gt; [2, 4, 6]
+</pre>
+
+ <p id="reject">
+ <b class="header">reject</b><code>_.reject(list, iterator, [context])</code>
+ <br />
+ Returns the values in <b>list</b> without the elements that the truth
+ test (<b>iterator</b>) passes. The opposite of <b>filter</b>.
+ </p>
+ <pre>
+var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=&gt; [1, 3, 5]
+</pre>
+
+ <p id="all">
+ <b class="header">all</b><code>_.all(list, iterator, [context])</code>
+ <span class="alias">Alias: <b>every</b></span>
+ <br />
+ Returns <i>true</i> if all of the values in the <b>list</b> pass the <b>iterator</b>
+ truth test. Delegates to the native method <b>every</b>, if present.
+ </p>
+ <pre>
+_.all([true, 1, null, 'yes'], _.identity);
+=&gt; false
+</pre>
+
+ <p id="any">
+ <b class="header">any</b><code>_.any(list, [iterator], [context])</code>
+ <span class="alias">Alias: <b>some</b></span>
+ <br />
+ Returns <i>true</i> if any of the values in the <b>list</b> pass the
+ <b>iterator</b> truth test. Short-circuits and stops traversing the list
+ if a true element is found. Delegates to the native method <b>some</b>,
+ if present.
+ </p>
+ <pre>
+_.any([null, 0, 'yes', false]);
+=&gt; true
+</pre>
+
+ <p id="include">
+ <b class="header">include</b><code>_.include(list, value)</code>
+ <span class="alias">Alias: <b>contains</b></span>
+ <br />
+ Returns <i>true</i> if the <b>value</b> is present in the <b>list</b>, using
+ <i>===</i> to test equality. Uses <b>indexOf</b> internally, if <b>list</b>
+ is an Array.
+ </p>
+ <pre>
+_.include([1, 2, 3], 3);
+=&gt; true
+</pre>
+
+ <p id="invoke">
+ <b class="header">invoke</b><code>_.invoke(list, methodName, [*arguments])</code>
+ <br />
+ Calls the method named by <b>methodName</b> on each value in the <b>list</b>.
+ Any extra arguments passed to <b>invoke</b> will be forwarded on to the
+ method invocation.
+ </p>
+ <pre>
+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+=&gt; [[1, 5, 7], [1, 2, 3]]
+</pre>
+
+ <p id="pluck">
+ <b class="header">pluck</b><code>_.pluck(list, propertyName)</code>
+ <br />
+ A convenient version of what is perhaps the most common use-case for
+ <b>map</b>: extracting a list of property values.
+ </p>
+ <pre>
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.pluck(stooges, 'name');
+=&gt; ["moe", "larry", "curly"]
+</pre>
+
+ <p id="max">
+ <b class="header">max</b><code>_.max(list, [iterator], [context])</code>
+ <br />
+ Returns the maximum value in <b>list</b>. If <b>iterator</b> is passed,
+ it will be used on each value to generate the criterion by which the
+ value is ranked.
+ </p>
+ <pre>
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.max(stooges, function(stooge){ return stooge.age; });
+=&gt; {name : 'curly', age : 60};
+</pre>
+
+ <p id="min">
+ <b class="header">min</b><code>_.min(list, [iterator], [context])</code>
+ <br />
+ Returns the minimum value in <b>list</b>. If <b>iterator</b> is passed,
+ it will be used on each value to generate the criterion by which the
+ value is ranked.
+ </p>
+ <pre>
+var numbers = [10, 5, 100, 2, 1000];
+_.min(numbers);
+=&gt; 2
+</pre>
+
+ <p id="sortBy">
+ <b class="header">sortBy</b><code>_.sortBy(list, iterator, [context])</code>
+ <br />
+ Returns a sorted copy of <b>list</b>, ranked by the results of running
+ each value through <b>iterator</b>.
+ </p>
+ <pre>
+_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
+=&gt; [5, 4, 6, 3, 1, 2]
+</pre>
+
+ <p id="groupBy">
+ <b class="header">groupBy</b><code>_.groupBy(list, iterator)</code>
+ <br />
+ Splits a collection into sets, grouped by the result of running each
+ value through <b>iterator</b>. If <b>iterator</b> is a string instead of
+ a function, groups by the property named by <b>iterator</b> on each of
+ the values.
+ </p>
+ <pre>
+_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
+=&gt; {1: [1.3], 2: [2.1, 2.4]}
+
+_.groupBy(['one', 'two', 'three'], 'length');
+=&gt; {3: ["one", "two"], 5: ["three"]}
+</pre>
+
+ <p id="sortedIndex">
+ <b class="header">sortedIndex</b><code>_.sortedIndex(list, value, [iterator])</code>
+ <br />
+ Uses a binary search to determine the index at which the <b>value</b>
+ <i>should</i> be inserted into the <b>list</b> in order to maintain the <b>list</b>'s
+ sorted order. If an <b>iterator</b> is passed, it will be used to compute
+ the sort ranking of each value.
+ </p>
+ <pre>
+_.sortedIndex([10, 20, 30, 40, 50], 35);
+=&gt; 3
+</pre>
+
+ <p id="shuffle">
+ <b class="header">shuffle</b><code>_.shuffle(list)</code>
+ <br />
+ Returns a shuffled copy of the <b>list</b>, using a version of the
+ <a href="http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle">Fisher-Yates shuffle</a>.
+ </p>
+ <pre>
+_.shuffle([1, 2, 3, 4, 5, 6]);
+=&gt; [4, 1, 6, 3, 5, 2]
+</pre>
+
+ <p id="toArray">
+ <b class="header">toArray</b><code>_.toArray(list)</code>
+ <br />
+ Converts the <b>list</b> (anything that can be iterated over), into a
+ real Array. Useful for transmuting the <b>arguments</b> object.
+ </p>
+ <pre>
+(function(){ return _.toArray(arguments).slice(0); })(1, 2, 3);
+=&gt; [1, 2, 3]
+</pre>
+
+ <p id="size">
+ <b class="header">size</b><code>_.size(list)</code>
+ <br />
+ Return the number of values in the <b>list</b>.
+ </p>
+ <pre>
+_.size({one : 1, two : 2, three : 3});
+=&gt; 3
+</pre>
+
+ <h2 id="arrays">Array Functions</h2>
+
+ <p>
+ <i>Note: All array functions will also work on the <b>arguments</b> object.</i>
+ </p>
+
+ <p id="first">
+ <b class="header">first</b><code>_.first(array, [n])</code>
+ <span class="alias">Alias: <b>head</b></span>
+ <br />
+ Returns the first element of an <b>array</b>. Passing <b>n</b> will
+ return the first <b>n</b> elements of the array.
+ </p>
+ <pre>
+_.first([5, 4, 3, 2, 1]);
+=&gt; 5
+</pre>
+
+ <p id="initial">
+ <b class="header">initial</b><code>_.initial(array, [n])</code>
+ <br />
+ Returns everything but the last entry of the array. Especially useful on
+ the arguments object. Pass <b>n</b> to exclude the last <b>n</b> elements
+ from the result.
+ </p>
+ <pre>
+_.initial([5, 4, 3, 2, 1]);
+=&gt; [5, 4, 3, 2]
+</pre>
+
+ <p id="last">
+ <b class="header">last</b><code>_.last(array, [n])</code>
+ <br />
+ Returns the last element of an <b>array</b>. Passing <b>n</b> will return
+ the last <b>n</b> elements of the array.
+ </p>
+ <pre>
+_.last([5, 4, 3, 2, 1]);
+=&gt; 1
+</pre>
+
+ <p id="rest">
+ <b class="header">rest</b><code>_.rest(array, [index])</code>
+ <span class="alias">Alias: <b>tail</b></span>
+ <br />
+ Returns the <b>rest</b> of the elements in an array. Pass an <b>index</b>
+ to return the values of the array from that index onward.
+ </p>
+ <pre>
+_.rest([5, 4, 3, 2, 1]);
+=&gt; [4, 3, 2, 1]
+</pre>
+
+ <p id="compact">
+ <b class="header">compact</b><code>_.compact(array)</code>
+ <br />
+ Returns a copy of the <b>array</b> with all falsy values removed.
+ In JavaScript, <i>false</i>, <i>null</i>, <i>0</i>, <i>""</i>,
+ <i>undefined</i> and <i>NaN</i> are all falsy.
+ </p>
+ <pre>
+_.compact([0, 1, false, 2, '', 3]);
+=&gt; [1, 2, 3]
+</pre>
+
+ <p id="flatten">
+ <b class="header">flatten</b><code>_.flatten(array)</code>
+ <br />
+ Flattens a nested <b>array</b> (the nesting can be to any depth).
+ </p>
+ <pre>
+_.flatten([1, [2], [3, [[[4]]]]]);
+=&gt; [1, 2, 3, 4];
+</pre>
+
+ <p id="without">
+ <b class="header">without</b><code>_.without(array, [*values])</code>
+ <br />
+ Returns a copy of the <b>array</b> with all instances of the <b>values</b>
+ removed. <i>===</i> is used for the equality test.
+ </p>
+ <pre>
+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+=&gt; [2, 3, 4]
+</pre>
+
+ <p id="union">
+ <b class="header">union</b><code>_.union(*arrays)</code>
+ <br />
+ Computes the union of the passed-in <b>arrays</b>: the list of unique items,
+ in order, that are present in one or more of the <b>arrays</b>.
+ </p>
+ <pre>
+_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+=&gt; [1, 2, 3, 101, 10]
+</pre>
+
+ <p id="intersection">
+ <b class="header">intersection</b><code>_.intersection(*arrays)</code>
+ <br />
+ Computes the list of values that are the intersection of all the <b>arrays</b>.
+ Each value in the result is present in each of the <b>arrays</b>.
+ </p>
+ <pre>
+_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+=&gt; [1, 2]
+</pre>
+
+ <p id="difference">
+ <b class="header">difference</b><code>_.difference(array, *others)</code>
+ <br />
+ Similar to <b>without</b>, but returns the values from <b>array</b> that
+ are not present in the <b>other</b> arrays.
+ </p>
+ <pre>
+_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+=&gt; [1, 3, 4]
+</pre>
+
+ <p id="uniq">
+ <b class="header">uniq</b><code>_.uniq(array, [isSorted], [iterator])</code>
+ <span class="alias">Alias: <b>unique</b></span>
+ <br />
+ Produces a duplicate-free version of the <b>array</b>, using <i>===</i> to test
+ object equality. If you know in advance that the <b>array</b> is sorted,
+ passing <i>true</i> for <b>isSorted</b> will run a much faster algorithm.
+ If you want to compute unique items based on a transformation, pass an
+ <b>iterator</b> function.
+ </p>
+ <pre>
+_.uniq([1, 2, 1, 3, 1, 4]);
+=&gt; [1, 2, 3, 4]
+</pre>
+
+ <p id="zip">
+ <b class="header">zip</b><code>_.zip(*arrays)</code>
+ <br />
+ Merges together the values of each of the <b>arrays</b> 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, <b>zip.apply</b>
+ can transpose the matrix in a similar fashion.
+ </p>
+ <pre>
+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
+=&gt; [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
+</pre>
+
+ <p id="indexOf">
+ <b class="header">indexOf</b><code>_.indexOf(array, value, [isSorted])</code>
+ <br />
+ Returns the index at which <b>value</b> can be found in the <b>array</b>,
+ or <i>-1</i> if value is not present in the <b>array</b>. Uses the native
+ <b>indexOf</b> function unless it's missing. If you're working with a
+ large array, and you know that the array is already sorted, pass <tt>true</tt>
+ for <b>isSorted</b> to use a faster binary search.
+ </p>
+ <pre>
+_.indexOf([1, 2, 3], 2);
+=&gt; 1
+</pre>
+
+ <p id="lastIndexOf">
+ <b class="header">lastIndexOf</b><code>_.lastIndexOf(array, value)</code>
+ <br />
+ Returns the index of the last occurrence of <b>value</b> in the <b>array</b>,
+ or <i>-1</i> if value is not present. Uses the native <b>lastIndexOf</b>
+ function if possible.
+ </p>
+ <pre>
+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+=&gt; 4
+</pre>
+
+ <p id="range">
+ <b class="header">range</b><code>_.range([start], stop, [step])</code>
+ <br />
+ A function to create flexibly-numbered lists of integers, handy for
+ <tt>each</tt> and <tt>map</tt> loops. <b>start</b>, if omitted, defaults
+ to <i>0</i>; <b>step</b> defaults to <i>1</i>. Returns a list of integers
+ from <b>start</b> to <b>stop</b>, incremented (or decremented) by <b>step</b>,
+ exclusive.
+ </p>
+ <pre>
+_.range(10);
+=&gt; [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+_.range(1, 11);
+=&gt; [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+_.range(0, 30, 5);
+=&gt; [0, 5, 10, 15, 20, 25]
+_.range(0, -10, -1);
+=&gt; [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+_.range(0);
+=&gt; []
+</pre>
+
+ <h2 id="functions">Function (uh, ahem) Functions</h2>
+
+ <p id="bind">
+ <b class="header">bind</b><code>_.bind(function, object, [*arguments])</code>
+ <br />
+ Bind a <b>function</b> to an <b>object</b>, meaning that whenever
+ the function is called, the value of <i>this</i> will be the <b>object</b>.
+ Optionally, bind <b>arguments</b> to the <b>function</b> to pre-fill them,
+ also known as <b>partial application</b>.
+ </p>
+ <pre>
+var func = function(greeting){ return greeting + ': ' + this.name };
+func = _.bind(func, {name : 'moe'}, 'hi');
+func();
+=&gt; 'hi: moe'
+</pre>
+
+ <p id="bindAll">
+ <b class="header">bindAll</b><code>_.bindAll(object, [*methodNames])</code>
+ <br />
+ Binds a number of methods on the <b>object</b>, specified by
+ <b>methodNames</b>, 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
+ <i>this</i>. If no <b>methodNames</b> are provided, all of the object's
+ function properties will be bound to it.
+ </p>
+ <pre>
+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);
+=&gt; When the button is clicked, this.label will have the correct value...
+</pre>
+
+ <p id="memoize">
+ <b class="header">memoize</b><code>_.memoize(function, [hashFunction])</code>
+ <br />
+ Memoizes a given <b>function</b> by caching the computed result. Useful
+ for speeding up slow-running computations. If passed an optional
+ <b>hashFunction</b>, it will be used to compute the hash key for storing
+ the result, based on the arguments to the original function. The default
+ <b>hashFunction</b> just uses the first argument to the memoized function
+ as the key.
+ </p>
+ <pre>
+var fibonacci = _.memoize(function(n) {
+ return n &lt; 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+});
+</pre>
+
+ <p id="delay">
+ <b class="header">delay</b><code>_.delay(function, wait, [*arguments])</code>
+ <br />
+ Much like <b>setTimeout</b>, invokes <b>function</b> after <b>wait</b>
+ milliseconds. If you pass the optional <b>arguments</b>, they will be
+ forwarded on to the <b>function</b> when it is invoked.
+ </p>
+ <pre>
+var log = _.bind(console.log, console);
+_.delay(log, 1000, 'logged later');
+=&gt; 'logged later' // Appears after one second.
+</pre>
+
+ <p id="defer">
+ <b class="header">defer</b><code>_.defer(function)</code>
+ <br />
+ Defers invoking the <b>function</b> until the current call stack has cleared,
+ similar to using <b>setTimeout</b> with a delay of 0. Useful for performing
+ expensive computations or HTML rendering in chunks without blocking the UI thread
+ from updating.
+ </p>
+ <pre>
+_.defer(function(){ alert('deferred'); });
+// Returns from the function before the alert runs.
+</pre>
+
+ <p id="throttle">
+ <b class="header">throttle</b><code>_.throttle(function, wait)</code>
+ <br />
+ 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 <b>wait</b>
+ milliseconds. Useful for rate-limiting events that occur faster than you
+ can keep up with.
+ </p>
+ <pre>
+var throttled = _.throttle(updatePosition, 100);
+$(window).scroll(throttled);
+</pre>
+
+ <p id="debounce">
+ <b class="header">debounce</b><code>_.debounce(function, wait)</code>
+ <br />
+ Creates and returns a new debounced version of the passed function that
+ will postpone its execution until after
+ <b>wait</b> milliseconds have elapsed since the last time it
+ was invoked. Useful for implementing behavior that should only happen
+ <i>after</i> 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.
+ </p>
+ <pre>
+var lazyLayout = _.debounce(calculateLayout, 300);
+$(window).resize(lazyLayout);
+</pre>
+
+ <p id="once">
+ <b class="header">once</b><code>_.once(function)</code>
+ <br />
+ 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.
+ </p>
+ <pre>
+var initialize = _.once(createApplication);
+initialize();
+initialize();
+// Application is only created once.
+</pre>
+
+ <p id="after">
+ <b class="header">after</b><code>_.after(count, function)</code>
+ <br />
+ Creates a version of the function that will only be run after first
+ being called <b>count</b> times. Useful for grouping asynchronous responses,
+ where you want to be sure that all the async calls have finished, before
+ proceeding.
+ </p>
+ <pre>
+var renderNotes = _.after(notes.length, render);
+_.each(notes, function(note) {
+ note.asyncSave({success: renderNotes});
+});
+// renderNotes is run once, after all notes have saved.
+</pre>
+
+ <p id="wrap">
+ <b class="header">wrap</b><code>_.wrap(function, wrapper)</code>
+ <br />
+ Wraps the first <b>function</b> inside of the <b>wrapper</b> function,
+ passing it as the first argument. This allows the <b>wrapper</b> to
+ execute code before and after the <b>function</b> runs, adjust the arguments,
+ and execute it conditionally.
+ </p>
+ <pre>
+var hello = function(name) { return "hello: " + name; };
+hello = _.wrap(hello, function(func) {
+ return "before, " + func("moe") + ", after";
+});
+hello();
+=&gt; 'before, hello: moe, after'
+</pre>
+
+ <p id="compose">
+ <b class="header">compose</b><code>_.compose(*functions)</code>
+ <br />
+ Returns the composition of a list of <b>functions</b>, where each function
+ consumes the return value of the function that follows. In math terms,
+ composing the functions <i>f()</i>, <i>g()</i>, and <i>h()</i> produces
+ <i>f(g(h()))</i>.
+ </p>
+ <pre>
+var greet = function(name){ return "hi: " + name; };
+var exclaim = function(statement){ return statement + "!"; };
+var welcome = _.compose(exclaim, greet);
+welcome('moe');
+=&gt; 'hi: moe!'
+</pre>
+
+ <h2 id="objects">Object Functions</h2>
+
+ <p id="keys">
+ <b class="header">keys</b><code>_.keys(object)</code>
+ <br />
+ Retrieve all the names of the <b>object</b>'s properties.
+ </p>
+ <pre>
+_.keys({one : 1, two : 2, three : 3});
+=&gt; ["one", "two", "three"]
+</pre>
+
+ <p id="values">
+ <b class="header">values</b><code>_.values(object)</code>
+ <br />
+ Return all of the values of the <b>object</b>'s properties.
+ </p>
+ <pre>
+_.values({one : 1, two : 2, three : 3});
+=&gt; [1, 2, 3]
+</pre>
+
+ <p id="functions">
+ <b class="header">functions</b><code>_.functions(object)</code>
+ <span class="alias">Alias: <b>methods</b></span>
+ <br />
+ Returns a sorted list of the names of every method in an object &mdash;
+ that is to say, the name of every function property of the object.
+ </p>
+ <pre>
+_.functions(_);
+=&gt; ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...
+</pre>
+
+ <p id="extend">
+ <b class="header">extend</b><code>_.extend(destination, *sources)</code>
+ <br />
+ Copy all of the properties in the <b>source</b> objects over to the
+ <b>destination</b> object. It's in-order, so the last source will override
+ properties of the same name in previous arguments.
+ </p>
+ <pre>
+_.extend({name : 'moe'}, {age : 50});
+=&gt; {name : 'moe', age : 50}
+</pre>
+
+ <p id="defaults">
+ <b class="header">defaults</b><code>_.defaults(object, *defaults)</code>
+ <br />
+ Fill in missing properties in <b>object</b> with default values from the
+ <b>defaults</b> objects. As soon as the property is filled, further defaults
+ will have no effect.
+ </p>
+ <pre>
+var iceCream = {flavor : "chocolate"};
+_.defaults(iceCream, {flavor : "vanilla", sprinkles : "lots"});
+=&gt; {flavor : "chocolate", sprinkles : "lots"}
+</pre>
+
+ <p id="clone">
+ <b class="header">clone</b><code>_.clone(object)</code>
+ <br />
+ Create a shallow-copied clone of the <b>object</b>. Any nested objects
+ or arrays will be copied by reference, not duplicated.
+ </p>
+ <pre>
+_.clone({name : 'moe'});
+=&gt; {name : 'moe'};
+</pre>
+
+ <p id="tap">
+ <b class="header">tap</b><code>_.tap(object, interceptor)</code>
+ <br />
+ Invokes <b>interceptor</b> with the <b>object</b>, and then returns <b>object</b>.
+ The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.
+ </p>
+ <pre>
+_.chain([1,2,3,200])
+ .filter(function(num) { return num % 2 == 0; })
+ .tap(console.log)
+ .map(function(num) { return num * num })
+ .value();
+=&gt; [2, 200]
+=&gt; [4, 40000]
+</pre>
+
+ <p id="isEqual">
+ <b class="header">isEqual</b><code>_.isEqual(object, other)</code>
+ <br />
+ Performs an optimized deep comparison between the two objects, to determine
+ if they should be considered equal.
+ </p>
+ <pre>
+var moe = {name : 'moe', luckyNumbers : [13, 27, 34]};
+var clone = {name : 'moe', luckyNumbers : [13, 27, 34]};
+moe == clone;
+=&gt; false
+_.isEqual(moe, clone);
+=&gt; true
+</pre>
+
+ <p id="isEmpty">
+ <b class="header">isEmpty</b><code>_.isEmpty(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> contains no values.
+ </p>
+ <pre>
+_.isEmpty([1, 2, 3]);
+=&gt; false
+_.isEmpty({});
+=&gt; true
+</pre>
+
+ <p id="isElement">
+ <b class="header">isElement</b><code>_.isElement(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a DOM element.
+ </p>
+ <pre>
+_.isElement(jQuery('body')[0]);
+=&gt; true
+</pre>
+
+ <p id="isArray">
+ <b class="header">isArray</b><code>_.isArray(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is an Array.
+ </p>
+ <pre>
+(function(){ return _.isArray(arguments); })();
+=&gt; false
+_.isArray([1,2,3]);
+=&gt; true
+</pre>
+
+ <p id="isArguments">
+ <b class="header">isArguments</b><code>_.isArguments(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is an Arguments object.
+ </p>
+ <pre>
+(function(){ return _.isArguments(arguments); })(1, 2, 3);
+=&gt; true
+_.isArguments([1,2,3]);
+=&gt; false
+</pre>
+
+ <p id="isFunction">
+ <b class="header">isFunction</b><code>_.isFunction(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a Function.
+ </p>
+ <pre>
+_.isFunction(alert);
+=&gt; true
+</pre>
+
+ <p id="isString">
+ <b class="header">isString</b><code>_.isString(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a String.
+ </p>
+ <pre>
+_.isString("moe");
+=&gt; true
+</pre>
+
+ <p id="isNumber">
+ <b class="header">isNumber</b><code>_.isNumber(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a Number (including <tt>NaN</tt>).
+ </p>
+ <pre>
+_.isNumber(8.4 * 5);
+=&gt; true
+</pre>
+
+ <p id="isBoolean">
+ <b class="header">isBoolean</b><code>_.isBoolean(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is either <i>true</i> or <i>false</i>.
+ </p>
+ <pre>
+_.isBoolean(null);
+=&gt; false
+</pre>
+
+ <p id="isDate">
+ <b class="header">isDate</b><code>_.isDate(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a Date.
+ </p>
+ <pre>
+_.isDate(new Date());
+=&gt; true
+</pre>
+
+ <p id="isRegExp">
+ <b class="header">isRegExp</b><code>_.isRegExp(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is a RegExp.
+ </p>
+ <pre>
+_.isRegExp(/moe/);
+=&gt; true
+</pre>
+
+ <p id="isNaN">
+ <b class="header">isNaN</b><code>_.isNaN(object)</code>
+ <br />
+ Returns <i>true</i> if <b>object</b> is <i>NaN</i>.<br /> Note: this is not
+ the same as the native <b>isNaN</b> function, which will also return
+ true if the variable is <i>undefined</i>.
+ </p>
+ <pre>
+_.isNaN(NaN);
+=&gt; true
+isNaN(undefined);
+=&gt; true
+_.isNaN(undefined);
+=&gt; false
+</pre>
+
+ <p id="isNull">
+ <b class="header">isNull</b><code>_.isNull(object)</code>
+ <br />
+ Returns <i>true</i> if the value of <b>object</b> is <i>null</i>.
+ </p>
+ <pre>
+_.isNull(null);
+=&gt; true
+_.isNull(undefined);
+=&gt; false
+</pre>
+
+ <p id="isUndefined">
+ <b class="header">isUndefined</b><code>_.isUndefined(variable)</code>
+ <br />
+ Returns <i>true</i> if <b>variable</b> is <i>undefined</i>.
+ </p>
+ <pre>
+_.isUndefined(window.missingVariable);
+=&gt; true
+</pre>
+
+ <h2 id="utility">Utility Functions</h2>
+
+ <p id="noConflict">
+ <b class="header">noConflict</b><code>_.noConflict()</code>
+ <br />
+ Give control of the "_" variable back to its previous owner. Returns
+ a reference to the <b>Underscore</b> object.
+ </p>
+ <pre>
+var underscore = _.noConflict();</pre>
+
+ <p id="identity">
+ <b class="header">identity</b><code>_.identity(value)</code>
+ <br />
+ Returns the same value that is used as the argument. In math:
+ <tt>f(x) = x</tt><br />
+ This function looks useless, but is used throughout Underscore as
+ a default iterator.
+ </p>
+ <pre>
+var moe = {name : 'moe'};
+moe === _.identity(moe);
+=&gt; true</pre>
+
+ <p id="times">
+ <b class="header">times</b><code>_.times(n, iterator)</code>
+ <br />
+ Invokes the given iterator function <b>n</b> times.
+ </p>
+ <pre>
+_(3).times(function(){ genie.grantWish(); });</pre>
+
+ <p id="mixin">
+ <b class="header">mixin</b><code>_.mixin(object)</code>
+ <br />
+ Allows you to extend Underscore with your own utility functions. Pass
+ a hash of <tt>{name: function}</tt> definitions to have your functions
+ added to the Underscore object, as well as the OOP wrapper.
+ </p>
+ <pre>
+_.mixin({
+ capitalize : function(string) {
+ return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
+ }
+});
+_("fabio").capitalize();
+=&gt; "Fabio"
+</pre>
+
+ <p id="uniqueId">
+ <b class="header">uniqueId</b><code>_.uniqueId([prefix])</code>
+ <br />
+ Generate a globally-unique id for client-side models or DOM elements
+ that need one. If <b>prefix</b> is passed, the id will be appended to it.
+ </p>
+ <pre>
+_.uniqueId('contact_');
+=&gt; 'contact_104'</pre>
+
+ <p id="escape">
+ <b class="header">escape</b><code>_.escape(string)</code>
+ <br />
+ Escapes a string for insertion into HTML, replacing
+ <tt>&amp;</tt>, <tt>&lt;</tt>, <tt>&gt;</tt>, <tt>&quot;</tt>, <tt>&#x27;</tt>, and <tt>&#x2F;</tt> characters.
+ </p>
+ <pre>
+_.escape('Curly, Larry &amp; Moe');
+=&gt; "Curly, Larry &amp;amp; Moe"</pre>
+
+ <p id="template">
+ <b class="header">template</b><code>_.template(templateString, [context])</code>
+ <br />
+ 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<br />
+ <tt>&lt;%= &hellip; %&gt;</tt>, as well as execute arbitrary JavaScript code, with
+ <tt>&lt;% &hellip; %&gt;</tt>. If you wish to interpolate a value, and have
+ it be HTML-escaped, use <tt>&lt;%- &hellip; %&gt;</tt> When you evaluate a template function, pass in a
+ <b>context</b> object that has properties corresponding to the template's free
+ variables. If you're writing a one-off, you can pass the <b>context</b>
+ object as the second parameter to <b>template</b> in order to render
+ immediately instead of returning a template function.
+ </p>
+ <pre>
+var compiled = _.template("hello: &lt;%= name %&gt;");
+compiled({name : 'moe'});
+=&gt; "hello: moe"
+
+var list = "&lt;% _.each(people, function(name) { %&gt; &lt;li&gt;&lt;%= name %&gt;&lt;/li&gt; &lt;% }); %&gt;";
+_.template(list, {people : ['moe', 'curly', 'larry']});
+=&gt; "&lt;li&gt;moe&lt;/li&gt;&lt;li&gt;curly&lt;/li&gt;&lt;li&gt;larry&lt;/li&gt;"
+
+var template = _.template("&lt;b&gt;&lt;%- value %&gt;&lt;/b&gt;");
+template({value : '&lt;script&gt;'});
+=&gt; "&lt;b&gt;&amp;lt;script&amp;gt;&lt;/b&gt;"</pre>
+
+ <p>
+ You can also use <tt>print</tt> from within JavaScript code. This is
+ sometimes more convenient than using <tt>&lt;%= ... %&gt;</tt>.
+ </p>
+
+ <pre>
+var compiled = _.template("&lt;% print('Hello ' + epithet); %&gt;");
+compiled({epithet: "stooge"});
+=&gt; "Hello stooge."</pre>
+
+ <p>
+ 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 <b>interpolate</b> regex to match expressions that should be
+ interpolated verbatim, an <b>escape</b> regex to match expressions that should
+ be inserted after being HTML escaped, and an <b>evaluate</b> 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
+ <a href="http://github.com/janl/mustache.js#readme">Mustache.js</a>
+ style templating:
+ </p>
+
+ <pre>
+_.templateSettings = {
+ interpolate : /\{\{(.+?)\}\}/g
+};
+
+var template = _.template("Hello {{ name }}!");
+template({name : "Mustache"});
+=&gt; "Hello Mustache!"</pre>
+
+
+ <h2 id="chaining">Chaining</h2>
+
+ <p>
+ 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.
+ </p>
+
+ <pre>
+_.map([1, 2, 3], function(n){ return n * 2; });
+_([1, 2, 3]).map(function(n){ return n * 2; });</pre>
+
+ <p>
+ Using the object-oriented style allows you to chain together methods. Calling
+ <tt>chain</tt> on a wrapped object will cause all future method calls to
+ return wrapped objects as well. When you've finished the computation,
+ use <tt>value</tt> to retrieve the final value. Here's an example of chaining
+ together a <b>map/flatten/reduce</b>, in order to get the word count of
+ every word in a song.
+ </p>
+
+<pre>
+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();
+
+=&gt; {lumberjack : 2, all : 4, night : 2 ... }</pre>
+
+ <p>
+ In addition, the
+ <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/prototype">Array prototype's methods</a>
+ are proxied through the chained Underscore object, so you can slip a
+ <tt>reverse</tt> or a <tt>push</tt> into your chain, and continue to
+ modify the array.
+ </p>
+
+ <p id="chain">
+ <b class="header">chain</b><code>_.chain(obj)</code>
+ <br />
+ Returns a wrapped object. Calling methods on this object will continue
+ to return wrapped objects until <tt>value</tt> is used.
+ </p>
+ <pre>
+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();
+=&gt; "moe is 21"
+</pre>
+
+ <p id="value">
+ <b class="header">value</b><code>_(obj).value()</code>
+ <br />
+ Extracts the value of a wrapped object.
+ </p>
+ <pre>
+_([1, 2, 3]).value();
+=&gt; [1, 2, 3]
+</pre>
+
+ <h2 id="links">Links &amp; Suggested Reading</h2>
+
+ <p>
+ <a href="http://mirven.github.com/underscore.lua/">Underscore.lua</a>,
+ a Lua port of the functions that are applicable in both languages.
+ Includes OOP-wrapping and chaining.
+ The <a href="http://github.com/mirven/underscore.lua">source</a> is
+ available on GitHub.
+ </p>
+
+ <p>
+ <a href="http://brianhaveri.github.com/Underscore.php/">Underscore.php</a>,
+ a PHP port of the functions that are applicable in both languages.
+ Includes OOP-wrapping and chaining.
+ The <a href="http://github.com/brianhaveri/Underscore.php">source</a> is
+ available on GitHub.
+ </p>
+
+ <p>
+ <a href="http://vti.github.com/underscore-perl/">Underscore-perl</a>,
+ a Perl port of many of the Underscore.js functions,
+ aimed at on Perl hashes and arrays, also
+ <a href="https://github.com/vti/underscore-perl/">available on GitHub</a>.
+ </p>
+
+ <p>
+ <a href="https://github.com/edtsech/underscore.string">Underscore.string</a>,
+ an Underscore extension that adds functions for string-manipulation:
+ <tt>trim</tt>, <tt>startsWith</tt>, <tt>contains</tt>, <tt>capitalize</tt>,
+ <tt>reverse</tt>, <tt>sprintf</tt>, and more.
+ </p>
+
+ <p>
+ Ruby's <a href="http://ruby-doc.org/core/classes/Enumerable.html">Enumerable</a> module.
+ </p>
+
+ <p>
+ <a href="http://www.prototypejs.org/">Prototype.js</a>, which provides
+ JavaScript with collection functions in the manner closest to Ruby's Enumerable.
+ </p>
+
+ <p>
+ Oliver Steele's
+ <a href="http://osteele.com/sources/javascript/functional/">Functional JavaScript</a>,
+ which includes comprehensive higher-order function support as well as string lambdas.
+ </p>
+
+ <p>
+ Michael Aufreiter's <a href="http://substance.io/#michael/data-js">Data.js</a>,
+ a data manipulation + persistence library for JavaScript.
+ </p>
+
+ <p>
+ Python's <a href="http://docs.python.org/library/itertools.html">itertools</a>.
+ </p>
+
+ <h2 id="changelog">Change Log</h2>
+
+ <p>
+ <b class="header">1.2.4</b> &mdash; <small><i>Jan. 4, 2012</i></small><br />
+ <ul>
+ <li>
+ You now can (and probably should) write <tt>_.chain(list)</tt>
+ instead of <tt>_(list).chain()</tt>.
+ </li>
+ <li>
+ Fix for escaped characters in Underscore templates, and for supporting
+ customizations of <tt>_.templateSettings</tt> that only define one or
+ two of the required regexes.
+ </li>
+ <li>
+ Fix for passing an array as the first argument to an <tt>_.wrap</tt>'d function.
+ </li>
+ <li>
+ Improved compatibility with ClojureScript, which adds a <tt>call</tt>
+ function to <tt>String.prototype</tt>.
+ </li>
+ </ul>
+ </p>
+
+ <p>
+ <b class="header">1.2.3</b> &mdash; <small><i>Dec. 7, 2011</i></small><br />
+ <ul>
+ <li>
+ Dynamic scope is now preserved for compiled <tt>_.template</tt> functions,
+ so you can use the value of <tt>this</tt> if you like.
+ </li>
+ <li>
+ Sparse array support of <tt>_.indexOf</tt>, <tt>_.lastIndexOf</tt>.
+ </li>
+ <li>
+ Both <tt>_.reduce</tt> and <tt>_.reduceRight</tt> can now be passed an
+ explicitly <tt>undefined</tt> value. (There's no reason why you'd
+ want to do this.)
+ </li>
+ </ul>
+ </p>
+
+ <p>
+ <b class="header">1.2.2</b> &mdash; <small><i>Nov. 14, 2011</i></small><br />
+ <ul>
+ <li>
+ Continued tweaks to <tt>_.isEqual</tt> semantics. Now JS primitives are
+ considered equivalent to their wrapped versions, and arrays are compared
+ by their numeric properties only <small>(#351)</small>.
+ </li>
+ <li>
+ <tt>_.escape</tt> no longer tries to be smart about not double-escaping
+ already-escaped HTML entities. Now it just escapes regardless <small>(#350)</small>.
+ </li>
+ <li>
+ In <tt>_.template</tt>, you may now leave semicolons out of evaluated
+ statements if you wish: <tt>&lt;% }) %&gt;</tt> <small>(#369)</small>.
+ </li>
+ <li>
+ <tt>_.after(callback, 0)</tt> will now trigger the callback immediately,
+ making "after" easier to use with asynchronous APIs <small>(#366)</small>.
+ </li>
+ </ul>
+ </p>
+
+ <p>
+ <b class="header">1.2.1</b> &mdash; <small><i>Oct. 24, 2011</i></small><br />
+ <ul>
+ <li>
+ Several important bug fixes for <tt>_.isEqual</tt>, which should now
+ do better on mutated Arrays, and on non-Array objects with
+ <tt>length</tt> properties. <small>(#329)</small>
+ </li>
+ <li>
+ <b>jrburke</b> contributed Underscore exporting for AMD module loaders,
+ and <b>tonylukasavage</b> for Appcelerator Titanium.
+ <small>(#335, #338)</small>
+ </li>
+ <li>
+ You can now <tt>_.groupBy(list, 'property')</tt> as a shortcut for
+ grouping values by a particular common property.
+ </li>
+ <li>
+ <tt>_.throttle</tt>'d functions now fire immediately upon invocation,
+ and are rate-limited thereafter <small>(#170, #266)</small>.
+ </li>
+ <li>
+ Most of the <tt>_.is[Type]</tt> checks no longer ducktype.
+ </li>
+ <li>
+ The <tt>_.bind</tt> function now also works on constructors, a-la
+ ES5 ... but you would never want to use <tt>_.bind</tt> on a
+ constructor function.
+ </li>
+ <li>
+ <tt>_.clone</tt> no longer wraps non-object types in Objects.
+ </li>
+ <li>
+ <tt>_.find</tt> and <tt>_.filter</tt> are now the preferred names for
+ <tt>_.detect</tt> and <tt>_.select</tt>.
+ </li>
+ </ul>
+ </p>
+
+ <p>
+ <b class="header">1.2.0</b> &mdash; <small><i>Oct. 5, 2011</i></small><br />
+ <ul>
+ <li>
+ The <tt>_.isEqual</tt> function now
+ supports true deep equality comparisons, with checks for cyclic structures,
+ thanks to Kit Cambridge.
+ </li>
+ <li>
+ Underscore templates now support HTML escaping interpolations, using
+ <tt>&lt;%- ... %&gt;</tt> syntax.
+ </li>
+ <li>
+ Ryan Tenney contributed <tt>_.shuffle</tt>, which uses a modified
+ Fisher-Yates to give you a shuffled copy of an array.
+ </li>
+ <li>
+ <tt>_.uniq</tt> can now be passed an optional iterator, to determine by
+ what criteria an object should be considered unique.
+ </li>
+ <li>
+ <tt>_.last</tt> now takes an optional argument which will return the last
+ N elements of the list.
+ </li>
+ <li>
+ A new <tt>_.initial</tt> function was added, as a mirror of <tt>_.rest</tt>,
+ which returns all the initial values of a list (except the last N).
+ </li>
+ </ul>
+ </p>
+
+ <p>
+ <b class="header">1.1.7</b> &mdash; <small><i>July 13, 2011</i></small><br />
+ Added <tt>_.groupBy</tt>, which aggregates a collection into groups of like items.
+ Added <tt>_.union</tt> and <tt>_.difference</tt>, to complement the
+ (re-named) <tt>_.intersection</tt>.
+ Various improvements for support of sparse arrays.
+ <tt>_.toArray</tt> now returns a clone, if directly passed an array.
+ <tt>_.functions</tt> now also returns the names of functions that are present
+ in the prototype chain.
+ </p>
+
+ <p>
+ <b class="header">1.1.6</b> &mdash; <small><i>April 18, 2011</i></small><br />
+ Added <tt>_.after</tt>, which will return a function that only runs after
+ first being called a specified number of times.
+ <tt>_.invoke</tt> can now take a direct function reference.
+ <tt>_.every</tt> now requires an iterator function to be passed, which
+ mirrors the ECMA5 API.
+ <tt>_.extend</tt> no longer copies keys when the value is undefined.
+ <tt>_.bind</tt> now errors when trying to bind an undefined value.
+ </p>
+
+ <p>
+ <b class="header">1.1.5</b> &mdash; <small><i>Mar 20, 2011</i></small><br />
+ Added an <tt>_.defaults</tt> function, for use merging together JS objects
+ representing default options.
+ Added an <tt>_.once</tt> function, for manufacturing functions that should
+ only ever execute a single time.
+ <tt>_.bind</tt> now delegates to the native ECMAScript 5 version,
+ where available.
+ <tt>_.keys</tt> now throws an error when used on non-Object values, as in
+ ECMAScript 5.
+ Fixed a bug with <tt>_.keys</tt> when used over sparse arrays.
+ </p>
+
+ <p>
+ <b class="header">1.1.4</b> &mdash; <small><i>Jan 9, 2011</i></small><br />
+ Improved compliance with ES5's Array methods when passing <tt>null</tt>
+ as a value. <tt>_.wrap</tt> now correctly sets <tt>this</tt> for the
+ wrapped function. <tt>_.indexOf</tt> now takes an optional flag for
+ finding the insertion index in an array that is guaranteed to already
+ be sorted. Avoiding the use of <tt>.callee</tt>, to allow <tt>_.isArray</tt>
+ to work properly in ES5's strict mode.
+ </p>
+
+ <p>
+ <b class="header">1.1.3</b> &mdash; <small><i>Dec 1, 2010</i></small><br />
+ In CommonJS, Underscore may now be required with just: <br />
+ <tt>var _ = require("underscore")</tt>.
+ Added <tt>_.throttle</tt> and <tt>_.debounce</tt> functions.
+ Removed <tt>_.breakLoop</tt>, in favor of an ECMA5-style un-<i>break</i>-able
+ each implementation &mdash; this removes the try/catch, and you'll now have
+ better stack traces for exceptions that are thrown within an Underscore iterator.
+ Improved the <b>isType</b> family of functions for better interoperability
+ with Internet Explorer host objects.
+ <tt>_.template</tt> now correctly escapes backslashes in templates.
+ Improved <tt>_.reduce</tt> compatibility with the ECMA5 version:
+ if you don't pass an initial value, the first item in the collection is used.
+ <tt>_.each</tt> no longer returns the iterated collection, for improved
+ consistency with ES5's <tt>forEach</tt>.
+ </p>
+
+ <p>
+ <b class="header">1.1.2</b><br />
+ Fixed <tt>_.contains</tt>, which was mistakenly pointing at
+ <tt>_.intersect</tt> instead of <tt>_.include</tt>, like it should
+ have been. Added <tt>_.unique</tt> as an alias for <tt>_.uniq</tt>.
+ </p>
+
+ <p>
+ <b class="header">1.1.1</b><br />
+ Improved the speed of <tt>_.template</tt>, and its handling of multiline
+ interpolations. Ryan Tenney contributed optimizations to many Underscore
+ functions. An annotated version of the source code is now available.
+ </p>
+
+ <p>
+ <b class="header">1.1.0</b><br />
+ The method signature of <tt>_.reduce</tt> has been changed to match
+ the ECMAScript 5 signature, instead of the Ruby/Prototype.js version.
+ This is a backwards-incompatible change. <tt>_.template</tt> may now be
+ called with no arguments, and preserves whitespace. <tt>_.contains</tt>
+ is a new alias for <tt>_.include</tt>.
+ </p>
+
+ <p>
+ <b class="header">1.0.4</b><br />
+ <a href="http://themoell.com/">Andri Möll</a> contributed the <tt>_.memoize</tt>
+ function, which can be used to speed up expensive repeated computations
+ by caching the results.
+ </p>
+
+ <p>
+ <b class="header">1.0.3</b><br />
+ Patch that makes <tt>_.isEqual</tt> return <tt>false</tt> if any property
+ of the compared object has a <tt>NaN</tt> value. Technically the correct
+ thing to do, but of questionable semantics. Watch out for NaN comparisons.
+ </p>
+
+ <p>
+ <b class="header">1.0.2</b><br />
+ Fixes <tt>_.isArguments</tt> in recent versions of Opera, which have
+ arguments objects as real Arrays.
+ </p>
+
+ <p>
+ <b class="header">1.0.1</b><br />
+ Bugfix for <tt>_.isEqual</tt>, when comparing two objects with the same
+ number of undefined keys, but with different names.
+ </p>
+
+ <p>
+ <b class="header">1.0.0</b><br />
+ Things have been stable for many months now, so Underscore is now
+ considered to be out of beta, at <b>1.0</b>. Improvements since <b>0.6</b>
+ include <tt>_.isBoolean</tt>, and the ability to have <tt>_.extend</tt>
+ take multiple source objects.
+ </p>
+
+ <p>
+ <b class="header">0.6.0</b><br />
+ Major release. Incorporates a number of
+ <a href="http://github.com/ratbeard">Mile Frawley's</a> refactors for
+ safer duck-typing on collection functions, and cleaner internals. A new
+ <tt>_.mixin</tt> method that allows you to extend Underscore with utility
+ functions of your own. Added <tt>_.times</tt>, which works the same as in
+ Ruby or Prototype.js. Native support for ECMAScript 5's <tt>Array.isArray</tt>,
+ and <tt>Object.keys</tt>.
+ </p>
+
+ <p>
+ <b class="header">0.5.8</b><br />
+ Fixed Underscore's collection functions to work on
+ <a href="https://developer.mozilla.org/En/DOM/NodeList">NodeLists</a> and
+ <a href="https://developer.mozilla.org/En/DOM/HTMLCollection">HTMLCollections</a>
+ once more, thanks to
+ <a href="http://github.com/jmtulloss">Justin Tulloss</a>.
+ </p>
+
+ <p>
+ <b class="header">0.5.7</b><br />
+ A safer implementation of <tt>_.isArguments</tt>, and a
+ faster <tt>_.isNumber</tt>,<br />thanks to
+ <a href="http://jedschmidt.com/">Jed Schmidt</a>.
+ </p>
+
+ <p>
+ <b class="header">0.5.6</b><br />
+ Customizable delimiters for <tt>_.template</tt>, contributed by
+ <a href="http://github.com/iamnoah">Noah Sloan</a>.
+ </p>
+
+ <p>
+ <b class="header">0.5.5</b><br />
+ Fix for a bug in MobileSafari's OOP-wrapper, with the arguments object.
+ </p>
+
+ <p>
+ <b class="header">0.5.4</b><br />
+ Fix for multiple single quotes within a template string for
+ <tt>_.template</tt>. See:
+ <a href="http://www.west-wind.com/Weblog/posts/509108.aspx">Rick Strahl's blog post</a>.
+ </p>
+
+ <p>
+ <b class="header">0.5.2</b><br />
+ New implementations of <tt>isArray</tt>, <tt>isDate</tt>, <tt>isFunction</tt>,
+ <tt>isNumber</tt>, <tt>isRegExp</tt>, and <tt>isString</tt>, thanks to
+ a suggestion from
+ <a href="http://www.broofa.com/">Robert Kieffer</a>.
+ Instead of doing <tt>Object#toString</tt>
+ 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.
+ <a href="http://dolzhenko.org/">Evgeniy Dolzhenko</a>
+ contributed <tt>_.tap</tt>,
+ <a href="http://ruby-doc.org/core-1.9/classes/Object.html#M000191">similar to Ruby 1.9's</a>,
+ which is handy for injecting side effects (like logging) into chained calls.
+ </p>
+
+ <p>
+ <b class="header">0.5.1</b><br />
+ Added an <tt>_.isArguments</tt> function. Lots of little safety checks
+ and optimizations contributed by
+ <a href="http://github.com/iamnoah/">Noah Sloan</a> and
+ <a href="http://themoell.com/">Andri Möll</a>.
+ </p>
+
+ <p>
+ <b class="header">0.5.0</b><br />
+ <b>[API Changes]</b> <tt>_.bindAll</tt> 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.
+ <tt>_.functions</tt> now takes a single argument and returns the names
+ of its Function properties. Calling <tt>_.functions(_)</tt> will get you
+ the previous behavior.
+ Added <tt>_.isRegExp</tt> so that <tt>isEqual</tt> can now test for RegExp equality.
+ All of the "is" functions have been shrunk down into a single definition.
+ <a href="http://github.com/grayrest/">Karl Guertin</a> contributed patches.
+ </p>
+
+ <p>
+ <b class="header">0.4.7</b><br />
+ Added <tt>isDate</tt>, <tt>isNaN</tt>, and <tt>isNull</tt>, for completeness.
+ Optimizations for <tt>isEqual</tt> when checking equality between Arrays
+ or Dates. <tt>_.keys</tt> is now <small><i><b>25%&ndash;2X</b></i></small> faster (depending on your
+ browser) which speeds up the functions that rely on it, such as <tt>_.each</tt>.
+ </p>
+
+ <p>
+ <b class="header">0.4.6</b><br />
+ Added the <tt>range</tt> function, a port of the
+ <a href="http://docs.python.org/library/functions.html#range">Python
+ function of the same name</a>, for generating flexibly-numbered lists
+ of integers. Original patch contributed by
+ <a href="http://github.com/kylichuku">Kirill Ishanov</a>.
+ </p>
+
+ <p>
+ <b class="header">0.4.5</b><br />
+ Added <tt>rest</tt> for Arrays and arguments objects, and aliased
+ <tt>first</tt> as <tt>head</tt>, and <tt>rest</tt> as <tt>tail</tt>,
+ thanks to <a href="http://github.com/lukesutton/">Luke Sutton</a>'s patches.
+ Added tests ensuring that all Underscore Array functions also work on
+ <i>arguments</i> objects.
+ </p>
+
+ <p>
+ <b class="header">0.4.4</b><br />
+ Added <tt>isString</tt>, and <tt>isNumber</tt>, for consistency. Fixed
+ <tt>_.isEqual(NaN, NaN)</tt> to return <i>true</i> (which is debatable).
+ </p>
+
+ <p>
+ <b class="header">0.4.3</b><br />
+ Started using the native <tt>StopIteration</tt> object in browsers that support it.
+ Fixed Underscore setup for CommonJS environments.
+ </p>
+
+ <p>
+ <b class="header">0.4.2</b><br />
+ Renamed the unwrapping function to <tt>value</tt>, for clarity.
+ </p>
+
+ <p>
+ <b class="header">0.4.1</b><br />
+ 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 <tt>breakLoop</tt> method
+ to <b>break</b> in the middle of any Underscore iteration. Added an
+ <tt>isEmpty</tt> function that works on arrays and objects.
+ </p>
+
+ <p>
+ <b class="header">0.4.0</b><br />
+ All Underscore functions can now be called in an object-oriented style,
+ like so: <tt>_([1, 2, 3]).map(...);</tt>. Original patch provided by
+ <a href="http://macournoyer.com/">Marc-André Cournoyer</a>.
+ Wrapped objects can be chained through multiple
+ method invocations. A <a href="#functions"><tt>functions</tt></a> method
+ was added, providing a sorted list of all the functions in Underscore.
+ </p>
+
+ <p>
+ <b class="header">0.3.3</b><br />
+ Added the JavaScript 1.8 function <tt>reduceRight</tt>. Aliased it
+ as <tt>foldr</tt>, and aliased <tt>reduce</tt> as <tt>foldl</tt>.
+ </p>
+
+ <p>
+ <b class="header">0.3.2</b><br />
+ Now runs on stock <a href="http://www.mozilla.org/rhino/">Rhino</a>
+ interpreters with: <tt>load("underscore.js")</tt>.
+ Added <a href="#identity"><tt>identity</tt></a> as a utility function.
+ </p>
+
+ <p>
+ <b class="header">0.3.1</b><br />
+ All iterators are now passed in the original collection as their third
+ argument, the same as JavaScript 1.6's <b>forEach</b>. Iterating over
+ objects is now called with <tt>(value, key, collection)</tt>, for details
+ see <a href="#each"><tt>_.each</tt></a>.
+ </p>
+
+ <p>
+ <b class="header">0.3.0</b><br />
+ Added <a href="http://github.com/dmitryBaranovskiy">Dmitry Baranovskiy</a>'s
+ comprehensive optimizations, merged in
+ <a href="http://github.com/kriskowal/">Kris Kowal</a>'s patches to make Underscore
+ <a href="http://wiki.commonjs.org/wiki/CommonJS">CommonJS</a> and
+ <a href="http://narwhaljs.org/">Narwhal</a> compliant.
+ </p>
+
+ <p>
+ <b class="header">0.2.0</b><br />
+ Added <tt>compose</tt> and <tt>lastIndexOf</tt>, renamed <tt>inject</tt> to
+ <tt>reduce</tt>, added aliases for <tt>inject</tt>, <tt>filter</tt>,
+ <tt>every</tt>, <tt>some</tt>, and <tt>forEach</tt>.
+ </p>
+
+ <p>
+ <b class="header">0.1.1</b><br />
+ Added <tt>noConflict</tt>, so that the "Underscore" object can be assigned to
+ other variables.
+ </p>
+
+ <p>
+ <b class="header">0.1.0</b><br />
+ Initial release of Underscore.js.
+ </p>
+
+ <p>
+ <a href="http://documentcloud.org/" title="A DocumentCloud Project" style="background:none;">
+ <img src="http://jashkenas.s3.amazonaws.com/images/a_documentcloud_project.png" alt="A DocumentCloud Project" />
+ </a>
+ </p>
+
+ </div>
+
+ </div>
+
+ <!-- Include Underscore, so you can play with it in the console. -->
+ <script type="text/javascript" src="underscore.js"></script>
+
+</body>
+</html>
View
1  node_modules/underscore/index.js
@@ -0,0 +1 @@
+module.exports = require('./underscore');
View
11 node_modules/underscore/package.json
@@ -0,0 +1,11 @@
+{
+ "name" : "underscore",
+ "description" : "JavaScript's functional programming helper library.",
+ "homepage" : "http://documentcloud.github.com/underscore/",
+ "keywords" : ["util", "functional", "server", "client", "browser"],
+ "author" : "Jeremy Ashkenas <jeremy@documentcloud.org>",
+ "contributors" : [],
+ "repository" : {"type": "git", "url": "git://github.com/documentcloud/underscore.git"},
+ "main" : "underscore.js",
+ "version" : "1.2.4"
+}
View
31 node_modules/underscore/underscore-min.js
@@ -0,0 +1,31 @@
+// Underscore.js 1.2.4
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+(function(){function r(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
+c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&r(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(m.call(a,h)&&(f++,!(g=m.call(c,h)&&r(a[h],c[h],d))))break;if(g){for(h in c)if(m.call(c,
+h)&&!f--)break;g=!f}}d.pop();return g}var s=this,G=s._,o={},k=Array.prototype,p=Object.prototype,i=k.slice,H=k.unshift,l=p.toString,m=p.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,q=k.indexOf,D=k.lastIndexOf,p=Array.isArray,I=Object.keys,t=Function.prototype.bind,b=function(a){return new n(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else typeof define==="function"&&define.amd?
+define("underscore",function(){return b}):s._=b;b.VERSION="1.2.4";var j=b.each=b.forEach=function(a,c,b){if(a!=null)if(w&&a.forEach===w)a.forEach(c,b);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(b,a[e],e,a)===o)break}else for(e in a)if(m.call(a,e)&&c.call(b,a[e],e,a)===o)break};b.map=function(a,c,b){var e=[];if(a==null)return e;if(x&&a.map===x)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};
+b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(y&&a.reduce===y)return e&&(c=b.bind(c,e)),f?a.reduce(c,d):a.reduce(c);j(a,function(a,b,i){f?d=c.call(e,d,a,b,i):(d=a,f=true)});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(z&&a.reduceRight===z)return e&&(c=b.bind(c,e)),f?a.reduceRight(c,d):a.reduceRight(c);var g=b.toArray(a).reverse();e&&!f&&
+(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=function(a,c,b){var e;E(a,function(a,g,h){if(c.call(b,a,g,h))return e=a,true});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(A&&a.filter===A)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;
+if(B&&a.every===B)return a.every(c,b);j(a,function(a,g,h){if(!(e=e&&c.call(b,a,g,h)))return o});return e};var E=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(C&&a.some===C)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return o});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;return q&&a.indexOf===q?a.indexOf(c)!=-1:b=E(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,
+function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,
+b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&(e={value:a,computed:b})});return e.value};b.shuffle=function(a){var c=[],b;j(a,function(a,f){f==0?c[0]=a:(b=Math.floor(Math.random()*(f+1)),c[f]=c[b],c[b]=a)});return c};b.sortBy=function(a,c,d){return b.pluck(b.map(a,function(a,b,g){return{value:a,criteria:c.call(d,a,b,g)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};j(a,function(a,b){var c=
+e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:a.toArray?a.toArray():b.isArray(a)?i.call(a):b.isArguments(a)?i.call(a):b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=b.head=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=
+null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,e=[];b.reduce(d,function(d,g,h){if(0==h||(c===true?b.last(d)!=
+g:!b.include(d,g)))d[d.length]=g,e[e.length]=a[h];return d},[]);return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1));return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=
+0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,d){if(a==null)return-1;var e;if(d)return d=b.sortedIndex(a,c),a[d]===c?d:-1;if(q&&a.indexOf===q)return a.indexOf(c);for(d=0,e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(D&&a.lastIndexOf===D)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){arguments.length<=1&&(b=a||0,a=0);for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-
+a)/d),0),f=0,g=Array(e);f<e;)g[f++]=a,a+=d;return g};var F=function(){};b.bind=function(a,c){var d,e;if(a.bind===t&&t)return t.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));F.prototype=a.prototype;var b=new F,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=
+b.bind(a[c],a)});return a};b.memoize=function(a,c){var d={};c||(c=b.identity);return function(){var b=c.apply(this,arguments);return m.call(d,b)?d[b]:d[b]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(a,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i=b.debounce(function(){h=g=false},c);return function(){d=this;e=arguments;var b;f||(f=setTimeout(function(){f=
+null;h&&a.apply(d,e);i()},c));g?h=true:a.apply(d,e);i();g=true}};b.debounce=function(a,b){var d;return function(){var e=this,f=arguments;clearTimeout(d);d=setTimeout(function(){d=null;a.apply(e,f)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=
+0;d--)b=[a[d].apply(this,b)];return b[0]}};b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=I||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var b=[],d;for(d in a)m.call(a,d)&&(b[b.length]=d);return b};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)b[d]!==
+void 0&&(a[d]=b[d])});return a};b.defaults=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return r(a,b,[])};b.isEmpty=function(a){if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(m.call(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=p||function(a){return l.call(a)==
+"[object Array]"};b.isObject=function(a){return a===Object(a)};b.isArguments=function(a){return l.call(a)=="[object Arguments]"};if(!b.isArguments(arguments))b.isArguments=function(a){return!(!a||!m.call(a,"callee"))};b.isFunction=function(a){return l.call(a)=="[object Function]"};b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};
+b.isDate=function(a){return l.call(a)=="[object Date]"};b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.noConflict=function(){s._=G;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};
+b.mixin=function(a){j(b.functions(a),function(c){J(c,b[c]=a[c])})};var K=0;b.uniqueId=function(a){var b=K++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var u=/.^/;b.template=function(a,c){var d=b.templateSettings,d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.escape||u,function(a,b){return"',_.escape("+b.replace(/\\'/g,"'")+"),'"}).replace(d.interpolate||
+u,function(a,b){return"',"+b.replace(/\\'/g,"'")+",'"}).replace(d.evaluate||u,function(a,b){return"');"+b.replace(/\\'/g,"'").replace(/[\r\n\t]/g," ").replace(/\\\\/g,"\\")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');",e=new Function("obj","_",d);return c?e(c,b):function(a){return e.call(this,a,b)}};b.chain=function(a){return b(a).chain()};var n=function(a){this._wrapped=a};b.prototype=n.prototype;var v=function(a,c){return c?b(a).chain():
+a},J=function(a,c){n.prototype[a]=function(){var a=i.call(arguments);H.call(a,this._wrapped);return v(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];n.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return v(d,this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];n.prototype[a]=function(){return v(b.apply(this._wrapped,arguments),this._chain)}});
+n.prototype.chain=function(){this._chain=true;return this};n.prototype.value=function(){return this._wrapped}}).call(this);
View
995 node_modules/underscore/underscore.js
@@ -0,0 +1,995 @@
+// Underscore.js 1.2.4
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+
+(function() {
+
+ // 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 slice = ArrayProto.slice,
+ 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) { return new wrapper(obj); };
+
+ // Export the Underscore object for **Node.js** and **"CommonJS"**, with
+ // backwards-compatibility for the old `require()` API. If we're not in
+ // CommonJS, add `_` to the global object.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else if (typeof define === 'function' && define.amd) {
+ // Register as a named module with AMD.
+ define('underscore', function() {
+ return _;
+ });
+ } else {
+ // Exported as a string, for Closure Compiler "advanced" mode.
+ root['_'] = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.2.4';
+
+ // 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 (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ for (var key in obj) {