pax_global_header00006660000000000000000000000064121021007040014475gustar00rootroot0000000000000052 comment=484bdb43ec4a9dd6a40e60a2d25317bec7aeb43f underscore-1.4.4/000077500000000000000000000000001210210070400136545ustar00rootroot00000000000000underscore-1.4.4/.gitignore000066400000000000000000000000211210210070400156350ustar00rootroot00000000000000raw node_modules underscore-1.4.4/.npmignore000066400000000000000000000000321210210070400156460ustar00rootroot00000000000000test/ Rakefile docs/ raw/ underscore-1.4.4/.travis.yml000066400000000000000000000001011210210070400157550ustar00rootroot00000000000000language: node_js node_js: - 0.8 notifications: email: false underscore-1.4.4/CNAME000066400000000000000000000000211210210070400144130ustar00rootroot00000000000000underscorejs.org underscore-1.4.4/CONTRIBUTING.md000066400000000000000000000012001210210070400160760ustar00rootroot00000000000000## 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/). * 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. underscore-1.4.4/LICENSE000066400000000000000000000020671210210070400146660ustar00rootroot00000000000000Copyright (c) 2009-2013 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. underscore-1.4.4/README.md000066400000000000000000000021611210210070400151330ustar00rootroot00000000000000 __ /\ \ __ __ __ ___ \_\ \ __ _ __ ____ ___ ___ _ __ __ /\_\ ____ /\ \/\ \ /' _ `\ /'_ \ /'__`\/\ __\/ ,__\ / ___\ / __`\/\ __\/'__`\ \/\ \ /',__\ \ \ \_\ \/\ \/\ \/\ \ \ \/\ __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\ __/ __ \ \ \/\__, `\ \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/ \/___/ \/_/\/_/\/__,_ /\/____/ \/_/ \/___/ \/____/\/___/ \/_/ \/____/\/_//\ \_\ \/___/ \ \____/ \/___/ 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 underscore-1.4.4/Rakefile000066400000000000000000000003411210210070400153170ustar00rootroot00000000000000desc "Use Uglify JS to compress Underscore.js" task :build do sh "uglifyjs underscore.js -c \"evaluate=false\" -m -o underscore-min.js" end desc "Build the docco documentation" task :doc do sh "docco underscore.js" end underscore-1.4.4/docs/000077500000000000000000000000001210210070400146045ustar00rootroot00000000000000underscore-1.4.4/docs/docco.css000066400000000000000000000160471210210070400164150ustar00rootroot00000000000000/*--------------------- 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 */underscore-1.4.4/docs/favicon.ico000066400000000000000000000025761210210070400167370ustar00rootroot00000000000000h( qA*underscore-1.4.4/docs/images/000077500000000000000000000000001210210070400160515ustar00rootroot00000000000000underscore-1.4.4/docs/images/background.png000066400000000000000000000040741210210070400207030ustar00rootroot00000000000000PNG  IHDR22]tEXtSoftwareAdobe ImageReadyqe<IDATxڼv:DQUISǶA1zP$rL@O>e߿v߽{>|y{)͛ym&Ը0{t62L#o9i`< O~9D _ޞW5;Z pVYbJ)nH!B:>۪>DˠY)͌MĜt 0mU+Y($&ϩ!U|}ݢzQڬ6'NIjdOQCWR5uJVZXtsuR +ed)ui{ #wЎpx$(9/%DBÝvKa@n{^;UɓnɿCΤ!Ķ1y7]OP#P؉AN3y5P2$*"!U :iv(i.k.~0i\\w`ujrmt"!6(v l/hml#Kkeaw䅐40MPF'Z4zƦxl'"i5$&sNvmjunQٶG8RfzV3Cd;nJ&tWsugXsv ˔PWZSѝB`IENDB`underscore-1.4.4/docs/images/underscore.png000066400000000000000000000206721210210070400207370ustar00rootroot00000000000000PNG  IHDR);tEXtSoftwareAdobe ImageReadyqe<!\IDATxrv!Y7s'[RuwzeLt ,?.KO Dm'J,:3W %nGl4pV+\+s?_$W,>=M;]6BF6?N<#z\QΟ%mmo hRvahٷ6)O㓯xXu`x9'9\1u["Ug42X=J;UͭQ9U6K:"-*"ֶchompm0ios|qC3 ?\gnY=I?S[ Պb^eǵ ;+wnfs^U(z+IԕISƚb q *KY C#ɧIeD:o0$i ڢ!?0`똒mpPD!2,*Jqf/AZًf&["ĊTI:z,QbC hNd~=1#`%BlC}C; opsk2O`- &gܩZ8@V{uܷiJPU+Į2udd,y?׺iuB|b޸9ff[\7`|uܻ^Y=-sexKqx2XFj>pRlLͭpqO E46Fӹ\JTODp^c}(+T6={ͤ&[,!ءh;׫]o}b}V4bQιZMV L\L0ZI\OTo{))aJǑ\6TIIX[FPE9lTPq<<+SF|BpViΕP'A*B )6$.7%O:[u|m91OZIG. OHE*mQN=y]Fuz<2oDrtWW&6q1\*SQI[Ūx30{/O+M m ͭC=66BKNW̟G++tPX*uo8]OKO2Q]?{lzkdN/Փ)G Nlq<&AdtLܖ .UUIRPWzBޫl+SUIqѯȚ3{̙fLL8-a0ϛLZݾNhUlTڲQ-#i~rVOA U7&o=ĖM>q1^I5fPjZ#ֶ_-V;gG9IVABB2xczղkz[+ShvPR't^j2%Խ`/O\ z@8{t}u`霱գZ]}B[a`'{@&97 0w`@;q[BzD 280&am<Ӥ-3[vlqT*RMH@بBB+FA%J^ڎ`?QU0%)Yhذ5HŒնN0!\>r)jie$2Uʭ0 fl.1 žW\.,PKa!.:LF"Ôuޒݳw8@?zN^#0qJw?e˔m%H ~Ed.ˇ J\ŖoKT8n8{P3>gB_S [Lxaz\ga Z? aN?QVg/Phyi}ZcaFJy/iՔXXj}Vr=~{'gWV-₉&i_!0`QJt$' %9xJfֳ?&?;vs[Nh>T<s$V)CDb,*DWZѡbKwS[X >X JsOm߈^A >ŽV)H5B)Xދp}hiͫj~hmRZ9OxȻ畯$> ,qV)Ȓ v^RWw5|}=z]}x{b7^AuJd-+>lscP(==" )8zA_˒^ƄOLQNRD{NcQ  8̀V)G:@/#P;o鳽~Bdd'NHJiFkKt*|Cc<.(>Cl3)\Z@`4gP* `(lO9aP_qK<´5J!er8)Ld]Qrph 0&ӋקiL,>ߕPs[I~@`4kP*!/_(Qq"=L UOl/R ׺. FDR~0$]:Z`8`OI`Z YpE7 w2d&n)׶U>L %Tbߞ$#( 0 !^lL6}'FALv !3 r Iq3ʕV)1&VUTȐ9aHlru;| <2l2_n@`4w`*6+hvR,ݙ!_,2+4~(!!bjk{G,brsDFl&h6J AąL L-w%2TRqߴ []!;3d?ΖBcO 6sTdp JJ}!mЊ<=疤X&s^s2iJSxp2=oE{>#~wҙ&ut8T+O܏V7N_pc@*jyccpQXՕ.}©2yS;B~$R*!Kخ1GcE骆,L:D`XuhrZh~R*Yخ]eoT0PAXȻ$z^eq*/@:?,"8[՞^;gxS܃y77!Z(D\-yCn8m(Kh"2jOH#,Bud۹AO)<@u8γVUҟ^f@u(7˱u*)۷* >d{ 4NbEUFBm ?apkp[Tޘ{^8tiQ+2м)(6BU:! }/*؈ϙ䨁g'}bC2B= L|B W^L9e]jbmHRh=T{ $o{'߬c!1+"Th=&*P-=p/Bf7n<+!*PFTسZzc[$ E MH9@hwy6vwpڟ^TAz?N)~ȾʡOBwĢў6چyMOa@s}4+"{cxZhzW Nj28ˍCgs{ڤ@^cz>иsFcXx 8'Zx˽YIfۃ5ScgZӷ ڣ1!2afMb5ӴŶi}Kx4^hNj&?"0rfPW,`3Dɂ2f`>DEWӰ*(c,0UĮn5F`x Rͣx caԜmUݵ&wQA<δe\G RdONt(ÆB Cd,jh00}FŐ>B&2L RM\NG> m{Bƨ@hy=cgoӆVGDmOGsGT30 g7}cGn"X+ϫC1\;uObëlM@wALdF47;8 *UDkiCë 0چmNZ5ǟg>n9 y}vZVRjr&90"0`LUL:C>+iN p)}UI`&p ZV:<8PӃ2^ExF ̥PmRj_BCi; 2cK9W`y~! f>%J K9Է8VK]6%ԭ ɾs}-q 2NQj$qiZݱc  ߡJ/&%y0UJJU2}S>:lhINYUJ|(iֳr {>9@tOۯʷQ?_ 1yV0\ QVPA?2JP{ $}c6)ό=R<,q&t˹e|%zJ1޲Zf1GD۹]%jS 4 3ȋPX-[BCarULLKȣ@3JUˁ%PH7PMEe 86!~X6ػ6]%|npV`.Q : r(*U gI1"='|Մ19\O4ĠO1%ӫgBel[ .ko#?4LpeC90U fwd靀u6A:)j#r=_Gnާ\#P ,AgfR%ɖ-Kc J]Rs,0ak[u6y=_ B#iU88pӲDZއ??8؏zuQX|ظZDWT[;rD:e+_e*,Ih3`:8.ZU*c,8[kY)-(lOﲉPѴ_-G†ohck:N6Ӑ5[yWDqqܳA$T2gv߮")>aF!EzBˀPڼŘAܱm~IAZ' %,NJn6*tb}[kV$܋ƎO畾'υjY7nY-r̅MO:=|Ǟfjlc}NWnZK|Ж6a_oJЙ3F_LධWlBD6}<юJy9ޮ>챧DLt'"θf[{Y FĸdEz9[Խ(KdˑȂDq7n7==Ti͛hMǭEL>-e;9sȱzQ`g{V~|8'pSdcz-0[*9ד q{icj-/86<XԜ5Cyt cSҍj GbۚkBǣT}Wodl&BOyy({L b}4yZx7XߓyOJmؼk+.޹#z0ED ,Z`>hQ蟽ұ=F-uU-L(+H툐7w)U7̝4ʪ6|RIZdO`~bסE݆ۭ1`lK"o-7dvfGJ=j M^^ YuKҠ/V1\m`_y"{{B,T/vbQ3T_C_x)8glb\{}0&_ʹkD0u\DB=U*pWOW ){yHrg>-lVnP F9MŢ4^uL~bHGf{gZ+Tcl\d]= fBoA(([lM_e;-|`kT8<r4'QNK?dvsb[mE5zTG:f߯t|@MrgvϯeՑVKx)\00;e Ypܳ r1o@B0`y>y PfjZymA`euV0:1kC`!A`gsD_b @^q5:=j>kԓ+;z&Eq"~.ʅ=ąV0Gq鿍zIls˲5ja|';K;Ԩ}̉XqN03JmE~X_AG7k5d;i",Fl܊__ mX_ Z^_,;}ʿlwOb}@<_?CMw<w*noY~ $m-PkEbXa17n]鿿=z5u_~.P_M)nL|M4g뉰XK)$Z.wk @` @` U`?K1fm{.e0wk+n6qq\ۛOɋkXlFYˑN_\qr$Ķ)&6Zz\UjC?*Mr\_k"/??? 0"fkru͆/_@`M`%ןb/E3_F%}%&IENDB`underscore-1.4.4/docs/underscore.html000066400000000000000000007460351210210070400176620ustar00rootroot00000000000000 underscore.js

underscore.js 

Underscore.js 1.4.4
http://underscorejs.org
(c) 2009-2013 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,
      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.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 (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;
  };

  var reduceError = 'Reduce of empty array with no initial value';
             		           
                               
                            
                                
               
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(reduceError);
    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 initial ? 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(reduceError);
    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) {
    return _.filter(obj, function(value, index, list) {
      return !iterator.call(context, value, index, list);
    }, context);
  };
             		           
                               
                            
                                
               
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) {
    if (obj == null) return false;
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
    return any(obj, function(value) {
      return value === target;
    });
  };
             		           
                               
                            
                                
               
Invoke a method (with arguments) on every item in a collection.
             		                            
  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
      return (isFunc ? 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
containing specific key:value pairs.
             		                            
  _.where = function(obj, attrs, first) {
    if (_.isEmpty(attrs)) return first ? null : [];
    return _[first ? 'find' : 'filter'](obj, function(value) {
      for (var key in attrs) {
        if (attrs[key] !== value[key]) return false;
      }
      return true;
    });
  };
             		           
                               
                            
                                
               
Convenience version of a common use case of find: getting the first object
containing specific key:value pairs.
             		                            
  _.findWhere = function(obj, attrs) {
    return _.where(obj, attrs, 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, value: -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, value: 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 || _.identity);
    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) {
      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 (_.isArray(obj)) return slice.call(obj);
    if (obj.length === +obj.length) return _.map(obj, _.identity);
    return _.values(obj);
  };
             		           
                               
                            
                                
               
Return the number of elements in an object.
             		                            
  _.size = function(obj) {
    if (obj == null) return 0;
    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) {
    if (array == null) return void 0;
    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 (array == null) return void 0;
    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, _.identity);
  };
             		           
                               
                            
                                
               
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) {
    if (_.isFunction(isSorted)) {
      context = iterator;
      iterator = isSorted;
      isSorted = false;
    }
    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) {
    if (list == null) return {};
    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
             		                            
             		           
                               
                            
                                
               
Create a function bound to a given object (assigning this, and arguments,
optionally). Delegates to ECMAScript 5's native Function.bind if
available.
             		                            
  _.bind = function(func, context) {
    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    var args = slice.call(arguments, 2);
    return function() {
      return func.apply(context, args.concat(slice.call(arguments)));
    };
  };
             		           
                               
                            
                                
               
Partially apply a function by creating a version that has had some of its
arguments pre-filled, without changing its dynamic this context.
             		                            
  _.partial = function(func) {
    var args = slice.call(arguments, 1);
    return function() {
      return func.apply(this, args.concat(slice.call(arguments)));
    };
  };
             		           
                               
                            
                                
               
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, result;
    var previous = 0;
    var later = function() {
      previous = new Date;
      timeout = null;
      result = func.apply(context, args);
    };
    return function() {
      var now = new Date;
      var remaining = wait - (now - previous);
      context = this;
      args = arguments;
      if (remaining <= 0) {
        clearTimeout(timeout);
        timeout = null;
        previous = now;
        result = func.apply(context, args);
      } else if (!timeout) {
        timeout = setTimeout(later, remaining);
      }
      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) {
      if (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) {
      if (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 isFinite(obj) && !isNaN(parseFloat(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) {
    var accum = Array(n);
    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
    return accum;
  };
             		           
                               
                            
                                
               
Return a random integer between min and max (inclusive).
             		                            
  _.random = function(min, max) {
    if (max == null) {
      max = min;
      min = 0;
    }
    return min + Math.floor(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) {
    var render;
    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]; });

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      }
      if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      }
      if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }
      index = offset + match.length;
      return match;
    });
    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 {
      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);


             		           
                     
   
   underscore-1.4.4/favicon.ico000066400000000000000000000025761210210070400160070ustar00rootroot00000000000000h( qA*underscore-1.4.4/index.html000066400000000000000000002576151210210070400156710ustar00rootroot00000000000000


  
  
  
  
  
  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.4)
        40kb, Uncompressed with Plentiful Comments
      

      

        Production Version (1.4.4)
        4kb, Minified and Gzipped
      

      

        

      

      

        Edge Version
        Unreleased, 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], alert);
=> alerts each number in turn...
_.each({one : 1, two : 2, three : 3}, alert);
=> alerts each number value 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}]



      

        findWhere_.findWhere(list, properties)
        

        Looks through the list and returns the first value that matches
        all of the key-value pairs listed in properties.
      

      
_.findWhere(publicServicePulitzers, {newsroom: "The New York Times"});
=> {year: 1918, newsroom: "The New York Times",
  reason: "For its public service in publishing in full so many official reports,
  documents and speeches by European statesmen relating to the progress and
  conduct of the war."}



      

        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]



      

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

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

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



      

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

        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.
      

      
_.some([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, [context])
        

        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, [context])
        

        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], [context])
        

        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, pass 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...



      

        partial_.partial(function, [*arguments])
        

        Partially apply a function by filling in any number of its arguments,
        without changing its dynamic this value. A close cousin
        of bind.
      

      
var add = function(a, b) { return a + b; };
add5 = _.partial(add, 5);
add5(10);
=> 15



      

        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.
        

        Note: this example uses the chaining syntax.
      

      
_(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.
      

      
_.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"


      

        unescape_.unescape(string)
        

        The opposite of escape, replaces
        &amp;, &lt;, &gt;,
        &quot;, &#x27;, and &#x2F;
        with their unescaped counterparts.
      

      
_.unescape('Curly, Larry &amp; Moe');
=> "Curly, Larry & 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.4 — Jan. 30, 2013 — Diff

        
    
          
  • 
            Added _.findWhere, for finding the first element in a list
            that matches a particular set of keys and values.
          
    • 
          
  • 
            Added _.partial, for partially applying a function without
            changing its dynamic reference to this.
          
    • 
          
  • 
            Simplified bind by removing some edge cases involving
            constructor functions. In short: don't _.bind your
            constructors.
          
    • 
          
  • 
            A minor optimization to invoke.
          
    • 
          
  • 
            Fix bug in the minified version due to the minifier incorrectly
            optimizing-away isFunction.
          
    • 
        

      


      

        1.4.3 — Dec. 4, 2012 — Diff

        
    
          
  • 
            Improved Underscore compatibility with Adobe's JS engine that can be
            used to script Illustrator, Photoshop, and friends.
          
    • 
          
  • 
            Added a default _.identity iterator to countBy and
            groupBy.
          
    • 
          
  • 
            The uniq function can now take array, iterator, context
            as the argument list.
          
    • 
          
  • 
            The times function now returns the mapped array of iterator
            results.
          
    • 
          
  • 
            Simplified and fixed bugs in throttle.
          
    • 
        

      


      

        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
        
      


    


  


  
  



underscore-1.4.4/index.js000066400000000000000000000000521210210070400153160ustar00rootroot00000000000000module.exports = require('./underscore');
underscore-1.4.4/package.json000066400000000000000000000011411210210070400161370ustar00rootroot00000000000000{
  "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.4",
  "devDependencies": {
    "phantomjs": "0.2.2"
  },
  "scripts": {
    "test": "phantomjs test/vendor/runner.js test/index.html?noglobals=true"
  }
}
underscore-1.4.4/test/000077500000000000000000000000001210210070400146335ustar00rootroot00000000000000underscore-1.4.4/test/arrays.js000066400000000000000000000234701210210070400165000ustar00rootroot00000000000000$(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 _.compact(arguments).length; })(0, 1, false, 2, false, 3);
    equal(result, 3, 'works on an arguments object');
  });

  test("flatten", function() {
    var list = [1, [2], [3, [[[4]]]]];
    deepEqual(_.flatten(list), [1,2,3,4], 'can flatten nested arrays');
    deepEqual(_.flatten(list, true), [1,2,3,[[[4]]]], 'can shallowly flatten nested arrays');
    var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
    deepEqual(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');

    equal(_.map(_.uniq(list, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator without specifying whether array is sorted');

    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];
    var 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');
  });

});
underscore-1.4.4/test/chaining.js000066400000000000000000000033061210210070400167530ustar00rootroot00000000000000$(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.');
  });

});
underscore-1.4.4/test/collections.js000066400000000000000000000412311210210070400175100ustar00rootroot00000000000000$(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;

    var 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');

    var context = "obj";

    var evens = _.reject([1, 2, 3, 4, 5, 6], function(num){
      equal(context, "obj");
      return num % 2 != 0;
    }, context);
    equal(evens.join(', '), '2, 4, 6', 'rejected each odd 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('findWhere', function() {
    var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}, {a: 2, b: 4}];
    var result = _.findWhere(list, {a: 1});
    deepEqual(result, {a: 1, b: 2});
    result = _.findWhere(list, {b: 4});
    deepEqual(result, {a: 1, b: 4});
  });

  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(_.max({'a': 'a'}), -Infinity, 'Maximum value of a non-numeric collection');

    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');
    equal(_.min({'a': 'a'}), Infinity, 'Minimum value of a non-numeric collection');

    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); });

    var array = [1, 2, 1, 2, 3];
    var grouped = _.groupBy(array);
    equal(grouped['1'].length, 2);
    equal(grouped['3'].length, 1);
  });

  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); });

    var array = [1, 2, 1, 2, 3];
    var grouped = _.countBy(array);
    equal(grouped['1'], 2);
    equal(grouped['3'], 1);
  });

  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 in IE < 9
    try {
      var actual = _.toArray(document.childNodes);
    } catch(ex) { }

    ok(_.isArray(actual), 'should not throw converting a node list');
  });

  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');
  });

});
underscore-1.4.4/test/functions.js000066400000000000000000000225651210210070400172130ustar00rootroot00000000000000$(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');

    func = _.bind(func, this, 'curly');
    equal(func(), 'hello: curly', 'the function was completely applied in advance');

    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(Boundf().hello, "moe curly", "When called without the new operator, it's OK to be bound to the context");
  });

  test("partial", function() {
    var obj = {name: 'moe'};
    var func = function() { return this.name + ' ' + _.toArray(arguments).join(' '); };

    obj.func = _.partial(func, 'a', 'b');
    equal(obj.func('c', 'd'), 'moe a b c d', 'can partially apply');
  });

  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, 32);
    throttledIncr(); throttledIncr();

    equal(counter, 1, "incr was called immediately");
    _.delay(function(){ equal(counter, 2, "incr was throttled"); start(); }, 64);
  });

  asyncTest("throttle arguments", 2, function() {
    var value = 0;
    var update = function(val){ value = val; };
    var throttledUpdate = _.throttle(update, 32);
    throttledUpdate(1); throttledUpdate(2);
    _.delay(function(){ throttledUpdate(3); }, 64);
    equal(value, 1, "updated to latest value");
    _.delay(function(){ equal(value, 3, "updated to latest value"); start(); }, 96);
  });

  asyncTest("throttle once", 2, function() {
    var counter = 0;
    var incr = function(){ return ++counter; };
    var throttledIncr = _.throttle(incr, 32);
    var result = throttledIncr();
    _.delay(function(){
      equal(result, 1, "throttled functions return their value");
      equal(counter, 1, "incr was called once"); start();
    }, 64);
  });

  asyncTest("throttle twice", 1, function() {
    var counter = 0;
    var incr = function(){ counter++; };
    var throttledIncr = _.throttle(incr, 32);
    throttledIncr(); throttledIncr();
    _.delay(function(){ equal(counter, 2, "incr was called twice"); start(); }, 64);
  });

  asyncTest("throttle repeatedly with results", 6, function() {
    var counter = 0;
    var incr = function(){ return ++counter; };
    var throttledIncr = _.throttle(incr, 64);
    var results = [];
    var saveResult = function() { results.push(throttledIncr()); };
    saveResult(); saveResult();
    _.delay(saveResult, 32);
    _.delay(saveResult, 80);
    _.delay(saveResult, 96);
    _.delay(saveResult, 144);
    _.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], 2, "incr was called twice");
      equal(results[4], 2, "incr was throttled");
      equal(results[5], 3, "incr was called trailing");
      start();
    }, 192);
  });

  asyncTest("throttle triggers trailing call when invoked repeatedly", 2, function() {
    var counter = 0;
    var limit = 48;
    var incr = function(){ counter++; };
    var throttledIncr = _.throttle(incr, 32);

    var stamp = new Date;
    while ((new Date - stamp) < limit) {
      throttledIncr();
    }
    var lastCount = counter;
    ok(counter > 1);

    _.delay(function() {
      ok(counter > lastCount);
      start();
    }, 96);
  });

  asyncTest("debounce", 1, function() {
    var counter = 0;
    var incr = function(){ counter++; };
    var debouncedIncr = _.debounce(incr, 32);
    debouncedIncr(); debouncedIncr();
    _.delay(debouncedIncr, 16);
    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 96);
  });

  asyncTest("debounce asap", 4, function() {
    var a, b;
    var counter = 0;
    var incr = function(){ return ++counter; };
    var debouncedIncr = _.debounce(incr, 64, true);
    a = debouncedIncr();
    b = debouncedIncr();
    equal(a, 1);
    equal(b, 1);
    equal(counter, 1, 'incr was called immediately');
    _.delay(debouncedIncr, 16);
    _.delay(debouncedIncr, 32);
    _.delay(debouncedIncr, 48);
    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 128);
  });

  asyncTest("debounce asap recursively", 2, function() {
    var counter = 0;
    var debouncedIncr = _.debounce(function(){
      counter++;
      if (counter < 10) debouncedIncr();
    }, 32, true);
    debouncedIncr();
    equal(counter, 1, "incr was called immediately");
    _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 96);
  });

  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");
  });

});
underscore-1.4.4/test/index.html000066400000000000000000000025021210210070400166270ustar00rootroot00000000000000


  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.
  

  

  


underscore-1.4.4/test/objects.js000066400000000000000000000640671210210070400166370ustar00rootroot00000000000000$(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');

    try {
      result = {};
      _.extend(result, null, undefined, {a:1});
    } catch(ex) {}

    equal(result.a, 1, 'should not error on `null` or `undefined` sources');
  });

  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');

    try {
      options = {};
      _.defaults(options, null, undefined, {a:1});
    } catch(ex) {}

    equal(options.a, 1, 'should not error on `null` or `undefined` sources');
  });

  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');

    a = _({x: 1, y: 2}).chain();
    b = _({x: 1, y: 2}).chain();
    equal(_.isEqual(a.isEqual(b), _(true)), true, '`isEqual` can be chained');

    // 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'), 'Numeric strings are numbers');
    ok(!_.isFinite('1a'), 'Non numeric strings are not numbers');
    ok(!_.isFinite(''), 'Empty 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');
  });

  test("has", function () {
     var obj = {foo: "bar", func: function () {} };
     ok (_.has(obj, "foo"), "has() checks that the object has a property.");
     ok (_.has(obj, "baz") == false, "has() returns false if the object doesn't have the property.");
     ok (_.has(obj, "func"), "has() works for functions too.");
     obj.hasOwnProperty = null;
     ok (_.has(obj, "foo"), "has() works even when the hasOwnProperty method is deleted.");
     var child = {};
     child.prototype = obj;
     ok (_.has(child, "foo") == false, "has() does not check the prototype chain for a property.")
  });
});
underscore-1.4.4/test/speed.js000066400000000000000000000035301210210070400162720ustar00rootroot00000000000000(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);
  });

})();
underscore-1.4.4/test/utility.js000066400000000000000000000236531210210070400167050ustar00rootroot00000000000000$(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("random", function() {
    var array = _.range(1000);
    var min = Math.pow(2, 31);
    var max = Math.pow(2, 62);

    ok(_.every(array, function() {
      return _.random(min, max) >= min;
    }), "should produce a random number greater than or equal to the minimum number");

    ok(_.some(array, function() {
      return _.random(Number.MAX_VALUE) > 0;
    }), "should produce a random number when passed `Number.MAX_VALUE`");
  });

  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");
    // collects return values
    ok(_.isEqual([0, 1, 2], _.times(3, function(i) { return i; })), "collects return values");
  });

  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 (var 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: "