lodash-rails 1.2.1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9089f7760c413d0fbdcce61c9c402fc9fecb166
-  data.tar.gz: 9a4cb9209a13b45d3448839f166382aba4515064
+  metadata.gz: 6c3d07e40e33fc43cb27c4c2b221bee184530e91
+  data.tar.gz: 4f03dba97d9e3e66da1167f76b1c10eb2551f389
 SHA512:
-  metadata.gz: 6a48be1a691143fcee7c3eb280adedf4225d5fee96969ee6377798fde1407ea9bb2e676bd29464f732784b8e1934e7624a817fef33ee66dc51b7c07293d9b426
-  data.tar.gz: 44a4d5b5b92f68715d9d488ae77bcb39591005572facf4e93564d3086e0095bb9a4bc41eb36472a73e76334b5c842a5256631db10cc039647eab856507343497
+  metadata.gz: 2e3e834d09b482a5276114505827391902cd0ec7f257789f78f26f33f0e4a77f1b88b9032ab4244da30c611262e5799a1af27f2801bc014e0cf05a49e440ab0b
+  data.tar.gz: 4856de9a072fecc4d3b5c4cbf6a59b80e3f242f87e09098ab68c3beb6e0a297297faa85e90ff08ea9cf50ebdccee3a6e81e67a1b26d32765e4779fb7a88d7ecf

data/README.md

@@ -18,7 +18,7 @@ Add the necessary library to `app/assets/javascripts/application.js`:
 
 ## What's included?
 
-Lo-Dash 1.2.1:
+Lo-Dash 1.3.1:
 
 * lodash.js
 * lodash.min.js

data/lib/lodash/rails/version.rb

@@ -1,5 +1,5 @@
 module LoDash
   module Rails
-    VERSION = "1.2.1"
+    VERSION = "1.3.1"
   end
 end

data/vendor/assets/javascripts/lodash.compat.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * Lo-Dash 1.2.1 (Custom Build) <http://lodash.com/>
+ * Lo-Dash 1.3.1 (Custom Build) <http://lodash.com/>
  * Build: `lodash -o ./dist/lodash.compat.js`
  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  * Based on Underscore.js 1.4.4 <http://underscorejs.org/>
@@ -12,17 +12,9 @@
   /** Used as a safe reference for `undefined` in pre ES5 environments */
   var undefined;
 
-  /** Detect free variable `exports` */
-  var freeExports = typeof exports == 'object' && exports;
-
-  /** Detect free variable `module` */
-  var freeModule = typeof module == 'object' && module && module.exports == freeExports && module;
-
-  /** Detect free variable `global`, from Node.js or Browserified code, and use it as `window` */
-  var freeGlobal = typeof global == 'object' && global;
-  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-    window = freeGlobal;
-  }
+  /** Used to pool arrays and objects used internally */
+  var arrayPool = [],
+      objectPool = [];
 
   /** Used to generate unique IDs */
   var idCounter = 0;
@@ -34,7 +26,10 @@
   var keyPrefix = +new Date + '';
 
   /** Used as the size when optimizations are enabled for large arrays */
-  var largeArraySize = 200;
+  var largeArraySize = 75;
+
+  /** Used as the max size of the `arrayPool` and `objectPool` */
+  var maxPoolSize = 40;
 
   /** Used to match empty string literals in compiled template source */
   var reEmptyStringLeading = /\b__p \+= '';/g,
@@ -56,6 +51,9 @@
   /** Used to match "interpolate" template delimiters */
   var reInterpolate = /<%=([\s\S]+?)%>/g;
 
+  /** Used to detect functions containing a `this` reference */
+  var reThis = (reThis = /\bthis\b/) && reThis.test(runInContext) && reThis;
+
   /** Used to detect and test whitespace */
   var whitespace = (
     // whitespace
@@ -82,9 +80,9 @@
 
   /** Used to assign default `context` object properties */
   var contextProps = [
-    'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object', 'RegExp',
-    'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN', 'parseInt',
-    'setImmediate', 'setTimeout'
+    'Array', 'Boolean', 'Date', 'Error', 'Function', 'Math', 'Number', 'Object',
+    'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',
+    'parseInt', 'setImmediate', 'setTimeout'
   ];
 
   /** Used to fix the JScript [[DontEnum]] bug */
@@ -101,6 +99,7 @@
       arrayClass = '[object Array]',
       boolClass = '[object Boolean]',
       dateClass = '[object Date]',
+      errorClass = '[object Error]',
       funcClass = '[object Function]',
       numberClass = '[object Number]',
       objectClass = '[object Object]',
@@ -136,6 +135,304 @@
     '\u2029': 'u2029'
   };
 
+  /** Detect free variable `exports` */
+  var freeExports = objectTypes[typeof exports] && exports;
+
+  /** Detect free variable `module` */
+  var freeModule = objectTypes[typeof module] && module && module.exports == freeExports && module;
+
+  /** Detect free variable `global`, from Node.js or Browserified code, and use it as `window` */
+  var freeGlobal = objectTypes[typeof global] && global;
+  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+    window = freeGlobal;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * A basic implementation of `_.indexOf` without support for binary searches
+   * or `fromIndex` constraints.
+   *
+   * @private
+   * @param {Array} array The array to search.
+   * @param {Mixed} value The value to search for.
+   * @param {Number} [fromIndex=0] The index to search from.
+   * @returns {Number} Returns the index of the matched value or `-1`.
+   */
+  function basicIndexOf(array, value, fromIndex) {
+    var index = (fromIndex || 0) - 1,
+        length = array.length;
+
+    while (++index < length) {
+      if (array[index] === value) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * An implementation of `_.contains` for cache objects that mimics the return
+   * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.
+   *
+   * @private
+   * @param {Object} cache The cache object to inspect.
+   * @param {Mixed} value The value to search for.
+   * @returns {Number} Returns `0` if `value` is found, else `-1`.
+   */
+  function cacheIndexOf(cache, value) {
+    var type = typeof value;
+    cache = cache.cache;
+
+    if (type == 'boolean' || value == null) {
+      return cache[value];
+    }
+    if (type != 'number' && type != 'string') {
+      type = 'object';
+    }
+    var key = type == 'number' ? value : keyPrefix + value;
+    cache = cache[type] || (cache[type] = {});
+
+    return type == 'object'
+      ? (cache[key] && basicIndexOf(cache[key], value) > -1 ? 0 : -1)
+      : (cache[key] ? 0 : -1);
+  }
+
+  /**
+   * Adds a given `value` to the corresponding cache object.
+   *
+   * @private
+   * @param {Mixed} value The value to add to the cache.
+   */
+  function cachePush(value) {
+    var cache = this.cache,
+        type = typeof value;
+
+    if (type == 'boolean' || value == null) {
+      cache[value] = true;
+    } else {
+      if (type != 'number' && type != 'string') {
+        type = 'object';
+      }
+      var key = type == 'number' ? value : keyPrefix + value,
+          typeCache = cache[type] || (cache[type] = {});
+
+      if (type == 'object') {
+        if ((typeCache[key] || (typeCache[key] = [])).push(value) == this.array.length) {
+          cache[type] = false;
+        }
+      } else {
+        typeCache[key] = true;
+      }
+    }
+  }
+
+  /**
+   * Used by `_.max` and `_.min` as the default `callback` when a given
+   * `collection` is a string value.
+   *
+   * @private
+   * @param {String} value The character to inspect.
+   * @returns {Number} Returns the code unit of given character.
+   */
+  function charAtCallback(value) {
+    return value.charCodeAt(0);
+  }
+
+  /**
+   * Used by `sortBy` to compare transformed `collection` values, stable sorting
+   * them in ascending order.
+   *
+   * @private
+   * @param {Object} a The object to compare to `b`.
+   * @param {Object} b The object to compare to `a`.
+   * @returns {Number} Returns the sort order indicator of `1` or `-1`.
+   */
+  function compareAscending(a, b) {
+    var ai = a.index,
+        bi = b.index;
+
+    a = a.criteria;
+    b = b.criteria;
+
+    // ensure a stable sort in V8 and other engines
+    // http://code.google.com/p/v8/issues/detail?id=90
+    if (a !== b) {
+      if (a > b || typeof a == 'undefined') {
+        return 1;
+      }
+      if (a < b || typeof b == 'undefined') {
+        return -1;
+      }
+    }
+    return ai < bi ? -1 : 1;
+  }
+
+  /**
+   * Creates a cache object to optimize linear searches of large arrays.
+   *
+   * @private
+   * @param {Array} [array=[]] The array to search.
+   * @returns {Null|Object} Returns the cache object or `null` if caching should not be used.
+   */
+  function createCache(array) {
+    var index = -1,
+        length = array.length;
+
+    var cache = getObject();
+    cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
+
+    var result = getObject();
+    result.array = array;
+    result.cache = cache;
+    result.push = cachePush;
+
+    while (++index < length) {
+      result.push(array[index]);
+    }
+    return cache.object === false
+      ? (releaseObject(result), null)
+      : result;
+  }
+
+  /**
+   * Used by `template` to escape characters for inclusion in compiled
+   * string literals.
+   *
+   * @private
+   * @param {String} match The matched character to escape.
+   * @returns {String} Returns the escaped character.
+   */
+  function escapeStringChar(match) {
+    return '\\' + stringEscapes[match];
+  }
+
+  /**
+   * Gets an array from the array pool or creates a new one if the pool is empty.
+   *
+   * @private
+   * @returns {Array} The array from the pool.
+   */
+  function getArray() {
+    return arrayPool.pop() || [];
+  }
+
+  /**
+   * Gets an object from the object pool or creates a new one if the pool is empty.
+   *
+   * @private
+   * @returns {Object} The object from the pool.
+   */
+  function getObject() {
+    return objectPool.pop() || {
+      'args': '',
+      'array': null,
+      'bottom': '',
+      'cache': null,
+      'criteria': null,
+      'false': false,
+      'firstArg': '',
+      'index': 0,
+      'init': '',
+      'leading': false,
+      'loop': '',
+      'maxWait': 0,
+      'null': false,
+      'number': null,
+      'object': null,
+      'push': null,
+      'shadowedProps': null,
+      'string': null,
+      'top': '',
+      'trailing': false,
+      'true': false,
+      'undefined': false,
+      'useHas': false,
+      'useKeys': false,
+      'value': null
+    };
+  }
+
+  /**
+   * Checks if `value` is a DOM node in IE < 9.
+   *
+   * @private
+   * @param {Mixed} value The value to check.
+   * @returns {Boolean} Returns `true` if the `value` is a DOM node, else `false`.
+   */
+  function isNode(value) {
+    // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
+    // methods that are `typeof` "string" and still can coerce nodes to strings
+    return typeof value.toString != 'function' && typeof (value + '') == 'string';
+  }
+
+  /**
+   * A no-operation function.
+   *
+   * @private
+   */
+  function noop() {
+    // no operation performed
+  }
+
+  /**
+   * Releases the given `array` back to the array pool.
+   *
+   * @private
+   * @param {Array} [array] The array to release.
+   */
+  function releaseArray(array) {
+    array.length = 0;
+    if (arrayPool.length < maxPoolSize) {
+      arrayPool.push(array);
+    }
+  }
+
+  /**
+   * Releases the given `object` back to the object pool.
+   *
+   * @private
+   * @param {Object} [object] The object to release.
+   */
+  function releaseObject(object) {
+    var cache = object.cache;
+    if (cache) {
+      releaseObject(cache);
+    }
+    object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;
+    if (objectPool.length < maxPoolSize) {
+      objectPool.push(object);
+    }
+  }
+
+  /**
+   * Slices the `collection` from the `start` index up to, but not including,
+   * the `end` index.
+   *
+   * Note: This function is used, instead of `Array#slice`, to support node lists
+   * in IE < 9 and to ensure dense arrays are returned.
+   *
+   * @private
+   * @param {Array|Object|String} collection The collection to slice.
+   * @param {Number} start The start index.
+   * @param {Number} end The end index.
+   * @returns {Array} Returns the new array.
+   */
+  function slice(array, start, end) {
+    start || (start = 0);
+    if (typeof end == 'undefined') {
+      end = array ? array.length : 0;
+    }
+    var index = -1,
+        length = end - start || 0,
+        result = Array(length < 0 ? 0 : length);
+
+    while (++index < length) {
+      result[index] = array[start + index];
+    }
+    return result;
+  }
+
   /*--------------------------------------------------------------------------*/
 
   /**
@@ -158,6 +455,7 @@
     var Array = context.Array,
         Boolean = context.Boolean,
         Date = context.Date,
+        Error = context.Error,
         Function = context.Function,
         Math = context.Math,
         Number = context.Number,
@@ -166,16 +464,25 @@
         String = context.String,
         TypeError = context.TypeError;
 
-    /** Used for `Array` and `Object` method references */
-    var arrayRef = Array(),
-        objectRef = Object();
+    /**
+     * Used for `Array` method references.
+     *
+     * Normally `Array.prototype` would suffice, however, using an array literal
+     * avoids issues in Narwhal.
+     */
+    var arrayRef = [];
+
+    /** Used for native method references */
+    var errorProto = Error.prototype,
+        objectProto = Object.prototype,
+        stringProto = String.prototype;
 
     /** Used to restore the original `_` reference in `noConflict` */
     var oldDash = context._;
 
     /** Used to detect if a method is native */
     var reNative = RegExp('^' +
-      String(objectRef.valueOf)
+      String(objectProto.valueOf)
         .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
         .replace(/valueOf|for [^\]]+/g, '.+?') + '$'
     );
@@ -185,15 +492,18 @@
         clearTimeout = context.clearTimeout,
         concat = arrayRef.concat,
         floor = Math.floor,
+        fnToString = Function.prototype.toString,
         getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
-        hasOwnProperty = objectRef.hasOwnProperty,
+        hasOwnProperty = objectProto.hasOwnProperty,
         push = arrayRef.push,
+        propertyIsEnumerable = objectProto.propertyIsEnumerable,
         setImmediate = context.setImmediate,
         setTimeout = context.setTimeout,
-        toString = objectRef.toString;
+        toString = objectProto.toString;
 
     /* Native method shortcuts for methods with the same name as other `lodash` methods */
     var nativeBind = reNative.test(nativeBind = toString.bind) && nativeBind,
+        nativeCreate = reNative.test(nativeCreate =  Object.create) && nativeCreate,
         nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
         nativeIsFinite = context.isFinite,
         nativeIsNaN = context.isNaN,
@@ -213,11 +523,31 @@
     ctorByClass[arrayClass] = Array;
     ctorByClass[boolClass] = Boolean;
     ctorByClass[dateClass] = Date;
+    ctorByClass[funcClass] = Function;
     ctorByClass[objectClass] = Object;
     ctorByClass[numberClass] = Number;
     ctorByClass[regexpClass] = RegExp;
     ctorByClass[stringClass] = String;
 
+    /** Used to avoid iterating non-enumerable properties in IE < 9 */
+    var nonEnumProps = {};
+    nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true };
+    nonEnumProps[boolClass] = nonEnumProps[stringClass] = { 'constructor': true, 'toString': true, 'valueOf': true };
+    nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { 'constructor': true, 'toString': true };
+    nonEnumProps[objectClass] = { 'constructor': true };
+
+    (function() {
+      var length = shadowedProps.length;
+      while (length--) {
+        var prop = shadowedProps[length];
+        for (var className in nonEnumProps) {
+          if (hasOwnProperty.call(nonEnumProps, className) && !hasOwnProperty.call(nonEnumProps[className], prop)) {
+            nonEnumProps[className][prop] = false;
+          }
+        }
+      }
+    }());
+
     /*--------------------------------------------------------------------------*/
 
     /**
@@ -239,8 +569,8 @@
      * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
      * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `push`, `range`,
      * `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, `sortBy`, `splice`,
-     * `tap`, `throttle`, `times`, `toArray`, `union`, `uniq`, `unshift`, `unzip`,
-     * `values`, `where`, `without`, `wrap`, and `zip`
+     * `tap`, `throttle`, `times`, `toArray`, `transform`, `union`, `uniq`, `unshift`,
+     * `unzip`, `values`, `where`, `without`, `wrap`, and `zip`
      *
      * The non-chainable wrapper functions are:
      * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`,
@@ -256,6 +586,7 @@
      *
      * @name _
      * @constructor
+     * @alias chain
      * @category Chaining
      * @param {Mixed} value The value to wrap in a `lodash` instance.
      * @returns {Object} Returns a `lodash` instance.
@@ -287,6 +618,19 @@
        : new lodashWrapper(value);
     }
 
+    /**
+     * A fast path for creating `lodash` wrapper objects.
+     *
+     * @private
+     * @param {Mixed} value The value to wrap in a `lodash` instance.
+     * @returns {Object} Returns a `lodash` instance.
+     */
+    function lodashWrapper(value) {
+      this.__wrapped__ = value;
+    }
+    // ensure `new lodashWrapper` is an instance of `lodash`
+    lodashWrapper.prototype = lodash.prototype;
+
     /**
      * An object used to flag environments features.
      *
@@ -321,6 +665,15 @@
        */
       support.argsClass = isArguments(arguments);
 
+      /**
+       * Detect if `name` or `message` properties of `Error.prototype` are
+       * enumerable by default. (IE < 9, Safari < 5.1)
+       *
+       * @memberOf _.support
+       * @type Boolean
+       */
+      support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name');
+
       /**
        * Detect if `prototype` properties are enumerable by default.
        *
@@ -332,7 +685,7 @@
        * @memberOf _.support
        * @type Boolean
        */
-      support.enumPrototypes = ctor.propertyIsEnumerable('prototype');
+      support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype');
 
       /**
        * Detect if `Function#bind` exists and is inferred to be fast (all but V8).
@@ -488,77 +841,80 @@
       (obj.init) +
       ';\nif (!iterable) return result;\n' +
       (obj.top) +
-      ';\n';
-       if (obj.arrays) {
-      __p += 'var length = iterable.length; index = -1;\nif (' +
-      (obj.arrays) +
+      ';';
+       if (obj.array) {
+      __p += '\nvar length = iterable.length; index = -1;\nif (' +
+      (obj.array) +
       ') {  ';
        if (support.unindexedChars) {
       __p += '\n  if (isString(iterable)) {\n    iterable = iterable.split(\'\')\n  }  ';
        }
       __p += '\n  while (++index < length) {\n    ' +
       (obj.loop) +
-      '\n  }\n}\nelse {  ';
-        } else if (support.nonEnumArgs) {
+      ';\n  }\n}\nelse {  ';
+       } else if (support.nonEnumArgs) {
       __p += '\n  var length = iterable.length; index = -1;\n  if (length && isArguments(iterable)) {\n    while (++index < length) {\n      index += \'\';\n      ' +
       (obj.loop) +
-      '\n    }\n  } else {  ';
+      ';\n    }\n  } else {  ';
        }
 
        if (support.enumPrototypes) {
       __p += '\n  var skipProto = typeof iterable == \'function\';\n  ';
        }
 
+       if (support.enumErrorProps) {
+      __p += '\n  var skipErrorProps = iterable === errorProto || iterable instanceof Error;\n  ';
+       }
+
+          var conditions = [];    if (support.enumPrototypes) { conditions.push('!(skipProto && index == "prototype")'); }    if (support.enumErrorProps)  { conditions.push('!(skipErrorProps && (index == "message" || index == "name"))'); }
+
        if (obj.useHas && obj.useKeys) {
-      __p += '\n  var ownIndex = -1,\n      ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],\n      length = ownProps.length;\n\n  while (++ownIndex < length) {\n    index = ownProps[ownIndex];\n    ';
-       if (support.enumPrototypes) {
-      __p += 'if (!(skipProto && index == \'prototype\')) {\n  ';
+      __p += '\n  var ownIndex = -1,\n      ownProps = objectTypes[typeof iterable] && keys(iterable),\n      length = ownProps ? ownProps.length : 0;\n\n  while (++ownIndex < length) {\n    index = ownProps[ownIndex];\n';
+          if (conditions.length) {
+      __p += '    if (' +
+      (conditions.join(' && ')) +
+      ') {\n  ';
        }
       __p += 
-      (obj.loop);
-       if (support.enumPrototypes) {
-      __p += '}\n';
+      (obj.loop) +
+      ';    ';
+       if (conditions.length) {
+      __p += '\n    }';
        }
-      __p += '  }  ';
+      __p += '\n  }  ';
        } else {
-      __p += '\n  for (index in iterable) {';
-          if (support.enumPrototypes || obj.useHas) {
-      __p += '\n    if (';
-            if (support.enumPrototypes) {
-      __p += '!(skipProto && index == \'prototype\')';
-       }      if (support.enumPrototypes && obj.useHas) {
-      __p += ' && ';
-       }      if (obj.useHas) {
-      __p += 'hasOwnProperty.call(iterable, index)';
-       }
-      __p += ') {    ';
+      __p += '\n  for (index in iterable) {\n';
+          if (obj.useHas) { conditions.push("hasOwnProperty.call(iterable, index)"); }    if (conditions.length) {
+      __p += '    if (' +
+      (conditions.join(' && ')) +
+      ') {\n  ';
        }
       __p += 
       (obj.loop) +
       ';    ';
-       if (support.enumPrototypes || obj.useHas) {
+       if (conditions.length) {
       __p += '\n    }';
        }
       __p += '\n  }    ';
        if (support.nonEnumShadows) {
-      __p += '\n\n  var ctor = iterable.constructor;\n      ';
-       for (var k = 0; k < 7; k++) {
-      __p += '\n  index = \'' +
+      __p += '\n\n  if (iterable !== objectProto) {\n    var ctor = iterable.constructor,\n        isProto = iterable === (ctor && ctor.prototype),\n        className = iterable === stringProto ? stringClass : iterable === errorProto ? errorClass : toString.call(iterable),\n        nonEnum = nonEnumProps[className];\n      ';
+       for (k = 0; k < 7; k++) {
+      __p += '\n    index = \'' +
       (obj.shadowedProps[k]) +
-      '\';\n  if (';
-            if (obj.shadowedProps[k] == 'constructor') {
-      __p += '!(ctor && ctor.prototype === iterable) && ';
-            }
-      __p += 'hasOwnProperty.call(iterable, index)) {\n    ' +
+      '\';\n    if ((!(isProto && nonEnum[index]) && hasOwnProperty.call(iterable, index))';
+              if (!obj.useHas) {
+      __p += ' || (!nonEnum[index] && iterable[index] !== objectProto[index])';
+       }
+      __p += ') {\n      ' +
       (obj.loop) +
-      '\n  }      ';
+      ';\n    }      ';
        }
-
+      __p += '\n  }    ';
        }
 
        }
 
-       if (obj.arrays || support.nonEnumArgs) {
+       if (obj.array || support.nonEnumArgs) {
       __p += '\n}';
        }
       __p += 
@@ -586,90 +942,18 @@
     var eachIteratorOptions = {
       'args': 'collection, callback, thisArg',
       'top': "callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg)",
-      'arrays': "typeof length == 'number'",
+      'array': "typeof length == 'number'",
       'loop': 'if (callback(iterable[index], index, collection) === false) return result'
     };
 
     /** Reusable iterator options for `forIn` and `forOwn` */
     var forOwnIteratorOptions = {
       'top': 'if (!objectTypes[typeof iterable]) return result;\n' + eachIteratorOptions.top,
-      'arrays': false
+      'array': false
     };
 
     /*--------------------------------------------------------------------------*/
 
-    /**
-     * Creates a function optimized to search large arrays for a given `value`,
-     * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`.
-     *
-     * @private
-     * @param {Array} array The array to search.
-     * @param {Mixed} value The value to search for.
-     * @returns {Boolean} Returns `true`, if `value` is found, else `false`.
-     */
-    function cachedContains(array) {
-      var length = array.length,
-          isLarge = length >= largeArraySize;
-
-      if (isLarge) {
-        var cache = {},
-            index = -1;
-
-        while (++index < length) {
-          var key = keyPrefix + array[index];
-          (cache[key] || (cache[key] = [])).push(array[index]);
-        }
-      }
-      return function(value) {
-        if (isLarge) {
-          var key = keyPrefix + value;
-          return  cache[key] && indexOf(cache[key], value) > -1;
-        }
-        return indexOf(array, value) > -1;
-      }
-    }
-
-    /**
-     * Used by `_.max` and `_.min` as the default `callback` when a given
-     * `collection` is a string value.
-     *
-     * @private
-     * @param {String} value The character to inspect.
-     * @returns {Number} Returns the code unit of given character.
-     */
-    function charAtCallback(value) {
-      return value.charCodeAt(0);
-    }
-
-    /**
-     * Used by `sortBy` to compare transformed `collection` values, stable sorting
-     * them in ascending order.
-     *
-     * @private
-     * @param {Object} a The object to compare to `b`.
-     * @param {Object} b The object to compare to `a`.
-     * @returns {Number} Returns the sort order indicator of `1` or `-1`.
-     */
-    function compareAscending(a, b) {
-      var ai = a.index,
-          bi = b.index;
-
-      a = a.criteria;
-      b = b.criteria;
-
-      // ensure a stable sort in V8 and other engines
-      // http://code.google.com/p/v8/issues/detail?id=90
-      if (a !== b) {
-        if (a > b || typeof a == 'undefined') {
-          return 1;
-        }
-        if (a < b || typeof b == 'undefined') {
-          return -1;
-        }
-      }
-      return ai < bi ? -1 : 1;
-    }
-
     /**
      * Creates a function that, when called, invokes `func` with the `this` binding
      * of `thisArg` and prepends any `partialArgs` to the arguments passed to the
@@ -716,9 +1000,7 @@
         }
         if (this instanceof bound) {
           // ensure `new bound` is an instance of `func`
-          noop.prototype = func.prototype;
-          thisBinding = new noop;
-          noop.prototype = null;
+          thisBinding = createObject(func.prototype);
 
           // mimic the constructor's `return` behavior
           // http://es5.github.com/#x13.2.2
@@ -735,7 +1017,7 @@
      *
      * @private
      * @param {Object} [options1, options2, ...] The compile options object(s).
-     *  arrays - A string of code to determine if the iterable is an array or array-like.
+     *  array - A string of code to determine if the iterable is an array or array-like.
      *  useHas - A boolean to specify using `hasOwnProperty` checks in the object loop.
      *  useKeys - A boolean to specify using `_.keys` for own property iteration.
      *  args - A string of comma separated arguments the iteration function will accept.
@@ -745,18 +1027,15 @@
      * @returns {Function} Returns the compiled function.
      */
     function createIterator() {
-      var data = {
-        // data properties
-        'shadowedProps': shadowedProps,
-        // iterator options
-        'arrays': 'isArray(iterable)',
-        'bottom': '',
-        'init': 'iterable',
-        'loop': '',
-        'top': '',
-        'useHas': true,
-        'useKeys': !!keys
-      };
+      var data = getObject();
+
+      // data properties
+      data.shadowedProps = shadowedProps;
+      // iterator options
+      data.array = data.bottom = data.loop = data.top = '';
+      data.init = 'iterable';
+      data.useHas = true;
+      data.useKeys = !!keys;
 
       // merge options into a template data object
       for (var object, index = 0; object = arguments[index]; index++) {
@@ -769,27 +1048,42 @@
 
       // create the function factory
       var factory = Function(
-          'hasOwnProperty, isArguments, isArray, isString, keys, ' +
-          'lodash, objectTypes',
+          'errorClass, errorProto, hasOwnProperty, isArguments, isArray, ' +
+          'isString, keys, lodash, objectProto, objectTypes, nonEnumProps, ' +
+          'stringClass, stringProto, toString',
         'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}'
       );
+
+      releaseObject(data);
+
       // return the compiled function
       return factory(
-        hasOwnProperty, isArguments, isArray, isString, keys,
-        lodash, objectTypes
+        errorClass, errorProto, hasOwnProperty, isArguments, isArray,
+        isString, keys, lodash, objectProto, objectTypes, nonEnumProps,
+        stringClass, stringProto, toString
       );
     }
 
     /**
-     * Used by `template` to escape characters for inclusion in compiled
-     * string literals.
+     * Creates a new object with the specified `prototype`.
      *
      * @private
-     * @param {String} match The matched character to escape.
-     * @returns {String} Returns the escaped character.
+     * @param {Object} prototype The prototype object.
+     * @returns {Object} Returns the new object.
      */
-    function escapeStringChar(match) {
-      return '\\' + stringEscapes[match];
+    function createObject(prototype) {
+      return isObject(prototype) ? nativeCreate(prototype) : {};
+    }
+    // fallback for browsers without `Object.create`
+    if  (!nativeCreate) {
+      var createObject = function(prototype) {
+        if (isObject(prototype)) {
+          noop.prototype = prototype;
+          var result = new noop;
+          noop.prototype = null;
+        }
+        return result || {};
+      };
     }
 
     /**
@@ -804,38 +1098,39 @@
     }
 
     /**
-     * Checks if `value` is a DOM node in IE < 9.
+     * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
+     * customized, this method returns the custom method, otherwise it returns
+     * the `basicIndexOf` function.
      *
      * @private
-     * @param {Mixed} value The value to check.
-     * @returns {Boolean} Returns `true` if the `value` is a DOM node, else `false`.
+     * @returns {Function} Returns the "indexOf" function.
      */
-    function isNode(value) {
-      // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
-      // methods that are `typeof` "string" and still can coerce nodes to strings
-      return typeof value.toString != 'function' && typeof (value + '') == 'string';
-    }
-
-    /**
-     * A fast path for creating `lodash` wrapper objects.
-     *
-     * @private
-     * @param {Mixed} value The value to wrap in a `lodash` instance.
-     * @returns {Object} Returns a `lodash` instance.
-     */
-    function lodashWrapper(value) {
-      this.__wrapped__ = value;
+    function getIndexOf(array, value, fromIndex) {
+      var result = (result = lodash.indexOf) === indexOf ? basicIndexOf : result;
+      return result;
     }
-    // ensure `new lodashWrapper` is an instance of `lodash`
-    lodashWrapper.prototype = lodash.prototype;
 
     /**
-     * A no-operation function.
+     * Creates a function that juggles arguments, allowing argument overloading
+     * for `_.flatten` and `_.uniq`, before passing them to the given `func`.
      *
      * @private
+     * @param {Function} func The function to wrap.
+     * @returns {Function} Returns the new function.
      */
-    function noop() {
-      // no operation performed
+    function overloadWrapper(func) {
+      return function(array, flag, callback, thisArg) {
+        // juggle arguments
+        if (typeof flag != 'boolean' && flag != null) {
+          thisArg = callback;
+          callback = !(thisArg && thisArg[flag] === array) ? flag : undefined;
+          flag = false;
+        }
+        if (callback != null) {
+          callback = lodash.createCallback(callback, thisArg);
+        }
+        return func(array, flag, callback, thisArg);
+      };
     }
 
     /**
@@ -849,62 +1144,33 @@
      * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
      */
     function shimIsPlainObject(value) {
-      // avoid non-objects and false positives for `arguments` objects
-      var result = false;
-      if (!(value && toString.call(value) == objectClass) || (!support.argsClass && isArguments(value))) {
-        return result;
-      }
-      // check that the constructor is `Object` (i.e. `Object instanceof Object`)
-      var ctor = value.constructor;
-
-      if (isFunction(ctor) ? ctor instanceof ctor : (support.nodeClass || !isNode(value))) {
-        // IE < 9 iterates inherited properties before own properties. If the first
-        // iterated property is an object's own property then there are no inherited
-        // enumerable properties.
-        if (support.ownLast) {
-          forIn(value, function(value, key, object) {
-            result = hasOwnProperty.call(object, key);
-            return false;
-          });
-          return result === true;
-        }
-        // In most environments an object's own properties are iterated before
-        // its inherited properties. If the last iterated property is an object's
-        // own property then there are no inherited enumerable properties.
-        forIn(value, function(value, key) {
-          result = key;
-        });
-        return result === false || hasOwnProperty.call(value, result);
-      }
-      return result;
-    }
+      var ctor,
+          result;
 
-    /**
-     * Slices the `collection` from the `start` index up to, but not including,
-     * the `end` index.
-     *
-     * Note: This function is used, instead of `Array#slice`, to support node lists
-     * in IE < 9 and to ensure dense arrays are returned.
-     *
-     * @private
-     * @param {Array|Object|String} collection The collection to slice.
-     * @param {Number} start The start index.
-     * @param {Number} end The end index.
-     * @returns {Array} Returns the new array.
-     */
-    function slice(array, start, end) {
-      start || (start = 0);
-      if (typeof end == 'undefined') {
-        end = array ? array.length : 0;
+      // avoid non Object objects, `arguments` objects, and DOM elements
+      if (!(value && toString.call(value) == objectClass) ||
+          (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor)) ||
+          (!support.argsClass && isArguments(value)) ||
+          (!support.nodeClass && isNode(value))) {
+        return false;
       }
-      var index = -1,
-          length = end - start || 0,
-          result = Array(length < 0 ? 0 : length);
-
-      while (++index < length) {
-        result[index] = array[start + index];
+      // IE < 9 iterates inherited properties before own properties. If the first
+      // iterated property is an object's own property then there are no inherited
+      // enumerable properties.
+      if (support.ownLast) {
+        forIn(value, function(value, key, object) {
+          result = hasOwnProperty.call(object, key);
+          return false;
+        });
+        return result !== false;
       }
-      return result;
+      // In most environments an object's own properties are iterated before
+      // its inherited properties. If the last iterated property is an object's
+      // own property then there are no inherited enumerable properties.
+      forIn(value, function(value, key) {
+        result = key;
+      });
+      return result === undefined || hasOwnProperty.call(value, result);
     }
 
     /**
@@ -979,8 +1245,7 @@
       'args': 'object',
       'init': '[]',
       'top': 'if (!(objectTypes[typeof object])) return result',
-      'loop': 'result.push(index)',
-      'arrays': false
+      'loop': 'result.push(index)'
     });
 
     /**
@@ -1021,7 +1286,7 @@
      * @param {Mixed} [thisArg] The `this` binding of `callback`.
      * @returns {Array|Object|String} Returns `collection`.
      */
-    var each = createIterator(eachIteratorOptions);
+    var basicEach = createIterator(eachIteratorOptions);
 
     /**
      * Used to convert characters to HTML entities:
@@ -1134,7 +1399,7 @@
 
       // allows working with "Collections" methods without using their `callback`
       // argument, `index|key`, for this method's `callback`
-      if (typeof deep == 'function') {
+      if (typeof deep != 'boolean' && deep != null) {
         thisArg = callback;
         callback = deep;
         deep = false;
@@ -1179,8 +1444,9 @@
           return ctor(result.source, reFlags.exec(result));
       }
       // check for circular references and return corresponding clone
-      stackA || (stackA = []);
-      stackB || (stackB = []);
+      var initedStack = !stackA;
+      stackA || (stackA = getArray());
+      stackB || (stackB = getArray());
 
       var length = stackA.length;
       while (length--) {
@@ -1206,10 +1472,14 @@
       stackB.push(result);
 
       // recursively populate clone (susceptible to call stack limits)
-      (isArr ? forEach : forOwn)(value, function(objValue, key) {
+      (isArr ? basicEach : forOwn)(value, function(objValue, key) {
         result[key] = clone(objValue, deep, callback, undefined, stackA, stackB);
       });
 
+      if (initedStack) {
+        releaseArray(stackA);
+        releaseArray(stackB);
+      }
       return result;
     }
 
@@ -1219,7 +1489,7 @@
      * `undefined`, cloning will be handled by the method instead. The `callback`
      * is bound to `thisArg` and invoked with one argument; (value).
      *
-     * Note: This function is loosely based on the structured clone algorithm. Functions
+     * Note: This method is loosely based on the structured clone algorithm. Functions
      * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
      * objects created by constructors other than `Object` are cloned to plain `Object` objects.
      * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
@@ -1656,8 +1926,9 @@
       // assume cyclic structures are equal
       // the algorithm for detecting cyclic structures is adapted from ES 5.1
       // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)
-      stackA || (stackA = []);
-      stackB || (stackB = []);
+      var initedStack = !stackA;
+      stackA || (stackA = getArray());
+      stackB || (stackB = getArray());
 
       var length = stackA.length;
       while (length--) {
@@ -1719,6 +1990,10 @@
           }
         });
       }
+      if (initedStack) {
+        releaseArray(stackA);
+        releaseArray(stackB);
+      }
       return result;
     }
 
@@ -1802,7 +2077,7 @@
       // http://es5.github.com/#x8
       // and avoid a V8 bug
       // http://code.google.com/p/v8/issues/detail?id=2291
-      return value ? objectTypes[typeof value] : false;
+      return !!(value && objectTypes[typeof value]);
     }
 
     /**
@@ -1923,7 +2198,7 @@
      * // => true
      */
     function isRegExp(value) {
-      return value ? (objectTypes[typeof value] && toString.call(value) == regexpClass) : false;
+      return !!(value && objectTypes[typeof value]) && toString.call(value) == regexpClass;
     }
 
     /**
@@ -2028,8 +2303,9 @@
             stackA = args[4],
             stackB = args[5];
       } else {
-        stackA = [];
-        stackB = [];
+        var initedStack = true;
+        stackA = getArray();
+        stackB = getArray();
 
         // allows working with `_.reduce` and `_.reduceRight` without
         // using their `callback` arguments, `index|key` and `collection`
@@ -2095,6 +2371,11 @@
           object[key] = value;
         });
       }
+
+      if (initedStack) {
+        releaseArray(stackA);
+        releaseArray(stackB);
+      }
       return object;
     }
 
@@ -2125,7 +2406,8 @@
      * // => { 'name': 'moe' }
      */
     function omit(object, callback, thisArg) {
-      var isFunc = typeof callback == 'function',
+      var indexOf = getIndexOf(),
+          isFunc = typeof callback == 'function',
           result = {};
 
       if (isFunc) {
@@ -2220,6 +2502,57 @@
       return result;
     }
 
+    /**
+     * An alternative to `_.reduce`, this method transforms an `object` to a new
+     * `accumulator` object which is the result of running each of its elements
+     * through the `callback`, with each `callback` execution potentially mutating
+     * the `accumulator` object. The `callback` is bound to `thisArg` and invoked
+     * with four arguments; (accumulator, value, key, object). Callbacks may exit
+     * iteration early by explicitly returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Array|Object} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [accumulator] The custom accumulator value.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the accumulated value.
+     * @example
+     *
+     * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
+     *   num *= num;
+     *   if (num % 2) {
+     *     return result.push(num) < 3;
+     *   }
+     * });
+     * // => [1, 9, 25]
+     *
+     * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+     *   result[key] = num * 3;
+     * });
+     * // => { 'a': 3, 'b': 6, 'c': 9 }
+     */
+    function transform(object, callback, accumulator, thisArg) {
+      var isArr = isArray(object);
+      callback = lodash.createCallback(callback, thisArg, 4);
+
+      if (accumulator == null) {
+        if (isArr) {
+          accumulator = [];
+        } else {
+          var ctor = object && object.constructor,
+              proto = ctor && ctor.prototype;
+
+          accumulator = createObject(proto);
+        }
+      }
+      (isArr ? basicEach : forOwn)(object, function(value, index, object) {
+        return callback(accumulator, value, index, object);
+      });
+      return accumulator;
+    }
+
     /**
      * Creates an array composed of the own enumerable property values of `object`.
      *
@@ -2312,17 +2645,18 @@
      */
     function contains(collection, target, fromIndex) {
       var index = -1,
+          indexOf = getIndexOf(),
           length = collection ? collection.length : 0,
           result = false;
 
       fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
-      if (typeof length == 'number') {
+      if (length && typeof length == 'number') {
         result = (isString(collection)
           ? collection.indexOf(target, fromIndex)
           : indexOf(collection, target, fromIndex)
         ) > -1;
       } else {
-        each(collection, function(value) {
+        basicEach(collection, function(value) {
           if (++index >= fromIndex) {
             return !(result = value === target);
           }
@@ -2430,7 +2764,7 @@
           }
         }
       } else {
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           return (result = !!callback(value, index, collection));
         });
       }
@@ -2492,7 +2826,7 @@
           }
         }
       } else {
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           if (callback(value, index, collection)) {
             result.push(value);
           }
@@ -2515,7 +2849,7 @@
      *
      * @static
      * @memberOf _
-     * @alias detect
+     * @alias detect, findWhere
      * @category Collections
      * @param {Array|Object|String} collection The collection to iterate over.
      * @param {Function|Object|String} [callback=identity] The function called per
@@ -2559,7 +2893,7 @@
         }
       } else {
         var result;
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           if (callback(value, index, collection)) {
             result = value;
             return false;
@@ -2602,7 +2936,7 @@
           }
         }
       } else {
-        each(collection, callback, thisArg);
+        basicEach(collection, callback, thisArg);
       }
       return collection;
     }
@@ -2737,7 +3071,7 @@
           result[index] = callback(collection[index], index, collection);
         }
       } else {
-        each(collection, function(value, key, collection) {
+        basicEach(collection, function(value, key, collection) {
           result[++index] = callback(value, key, collection);
         });
       }
@@ -2802,7 +3136,7 @@
           ? charAtCallback
           : lodash.createCallback(callback, thisArg);
 
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           var current = callback(value, index, collection);
           if (current > computed) {
             computed = current;
@@ -2871,7 +3205,7 @@
           ? charAtCallback
           : lodash.createCallback(callback, thisArg);
 
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           var current = callback(value, index, collection);
           if (current < computed) {
             computed = current;
@@ -2949,7 +3283,7 @@
           accumulator = callback(accumulator, collection[index], index, collection);
         }
       } else {
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           accumulator = noaccum
             ? (noaccum = false, value)
             : callback(accumulator, value, index, collection)
@@ -3152,7 +3486,7 @@
           }
         }
       } else {
-        each(collection, function(value, index, collection) {
+        basicEach(collection, function(value, index, collection) {
           return !(result = callback(value, index, collection));
         });
       }
@@ -3201,17 +3535,18 @@
 
       callback = lodash.createCallback(callback, thisArg);
       forEach(collection, function(value, key, collection) {
-        result[++index] = {
-          'criteria': callback(value, key, collection),
-          'index': index,
-          'value': value
-        };
+        var object = result[++index] = getObject();
+        object.criteria = callback(value, key, collection);
+        object.index = index;
+        object.value = value;
       });
 
       length = result.length;
       result.sort(compareAscending);
       while (length--) {
-        result[length] = result[length].value;
+        var object = result[length];
+        result[length] = object.value;
+        releaseObject(object);
       }
       return result;
     }
@@ -3311,17 +3646,31 @@
      */
     function difference(array) {
       var index = -1,
+          indexOf = getIndexOf(),
           length = array ? array.length : 0,
-          flattened = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
-          contains = cachedContains(flattened),
+          seen = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
           result = [];
 
+      var isLarge = length >= largeArraySize && indexOf === basicIndexOf;
+
+      if (isLarge) {
+        var cache = createCache(seen);
+        if (cache) {
+          indexOf = cacheIndexOf;
+          seen = cache;
+        } else {
+          isLarge = false;
+        }
+      }
       while (++index < length) {
         var value = array[index];
-        if (!contains(value)) {
+        if (indexOf(seen, value) < 0) {
           result.push(value);
         }
       }
+      if (isLarge) {
+        releaseObject(seen);
+      }
       return result;
     }
 
@@ -3477,20 +3826,11 @@
      * _.flatten(stooges, 'quotes');
      * // => ['Oh, a wise guy, eh?', 'Poifect!', 'Spread out!', 'You knucklehead!']
      */
-    function flatten(array, isShallow, callback, thisArg) {
+    var flatten = overloadWrapper(function flatten(array, isShallow, callback) {
       var index = -1,
           length = array ? array.length : 0,
           result = [];
 
-      // juggle arguments
-      if (typeof isShallow != 'boolean' && isShallow != null) {
-        thisArg = callback;
-        callback = isShallow;
-        isShallow = false;
-      }
-      if (callback != null) {
-        callback = lodash.createCallback(callback, thisArg);
-      }
       while (++index < length) {
         var value = array[index];
         if (callback) {
@@ -3504,7 +3844,7 @@
         }
       }
       return result;
-    }
+    });
 
     /**
      * Gets the index at which the first occurrence of `value` is found using
@@ -3531,21 +3871,14 @@
      * // => 2
      */
     function indexOf(array, value, fromIndex) {
-      var index = -1,
-          length = array ? array.length : 0;
-
       if (typeof fromIndex == 'number') {
-        index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1;
+        var length = array ? array.length : 0;
+        fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0);
       } else if (fromIndex) {
-        index = sortedIndex(array, value);
+        var index = sortedIndex(array, value);
         return array[index] === value ? index : -1;
       }
-      while (++index < length) {
-        if (array[index] === value) {
-          return index;
-        }
-      }
-      return -1;
+      return array ? basicIndexOf(array, value, fromIndex) : -1;
     }
 
     /**
@@ -3641,35 +3974,45 @@
     function intersection(array) {
       var args = arguments,
           argsLength = args.length,
-          cache = { '0': {} },
+          argsIndex = -1,
+          caches = getArray(),
           index = -1,
+          indexOf = getIndexOf(),
           length = array ? array.length : 0,
-          isLarge = length >= largeArraySize,
           result = [],
-          seen = result;
+          seen = getArray();
 
+      while (++argsIndex < argsLength) {
+        var value = args[argsIndex];
+        caches[argsIndex] = indexOf === basicIndexOf &&
+          (value ? value.length : 0) >= largeArraySize &&
+          createCache(argsIndex ? args[argsIndex] : seen);
+      }
       outer:
       while (++index < length) {
-        var value = array[index];
-        if (isLarge) {
-          var key = keyPrefix + value;
-          var inited = cache[0][key]
-            ? !(seen = cache[0][key])
-            : (seen = cache[0][key] = []);
-        }
-        if (inited || indexOf(seen, value) < 0) {
-          if (isLarge) {
-            seen.push(value);
-          }
-          var argsIndex = argsLength;
+        var cache = caches[0];
+        value = array[index];
+
+        if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) {
+          argsIndex = argsLength;
+          (cache || seen).push(value);
           while (--argsIndex) {
-            if (!(cache[argsIndex] || (cache[argsIndex] = cachedContains(args[argsIndex])))(value)) {
+            cache = caches[argsIndex];
+            if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) {
               continue outer;
             }
           }
           result.push(value);
         }
       }
+      while (argsLength--) {
+        cache = caches[argsLength];
+        if (cache) {
+          releaseObject(cache);
+        }
+      }
+      releaseArray(caches);
+      releaseArray(seen);
       return result;
     }
 
@@ -3998,7 +4341,7 @@
      * Creates a duplicate-value-free version of the `array` using strict equality
      * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`
      * for `isSorted` will run a faster algorithm. If `callback` is passed, each
-     * element of `array` is passed through a `callback` before uniqueness is computed.
+     * element of `array` is passed through the `callback` before uniqueness is computed.
      * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).
      *
      * If a property name is passed for `callback`, the created "_.pluck" style
@@ -4027,50 +4370,42 @@
      * _.uniq([1, 1, 2, 2, 3], true);
      * // => [1, 2, 3]
      *
-     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); });
-     * // => [1, 2, 3]
+     * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); });
+     * // => ['A', 'b', 'C']
      *
-     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math);
-     * // => [1, 2, 3]
+     * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+     * // => [1, 2.5, 3]
      *
      * // using "_.pluck" callback shorthand
      * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
      * // => [{ 'x': 1 }, { 'x': 2 }]
      */
-    function uniq(array, isSorted, callback, thisArg) {
+    var uniq = overloadWrapper(function(array, isSorted, callback) {
       var index = -1,
+          indexOf = getIndexOf(),
           length = array ? array.length : 0,
-          result = [],
-          seen = result;
+          result = [];
+
+      var isLarge = !isSorted && length >= largeArraySize && indexOf === basicIndexOf,
+          seen = (callback || isLarge) ? getArray() : result;
 
-      // juggle arguments
-      if (typeof isSorted != 'boolean' && isSorted != null) {
-        thisArg = callback;
-        callback = isSorted;
-        isSorted = false;
-      }
-      // init value cache for large arrays
-      var isLarge = !isSorted && length >= largeArraySize;
       if (isLarge) {
-        var cache = {};
-      }
-      if (callback != null) {
-        seen = [];
-        callback = lodash.createCallback(callback, thisArg);
+        var cache = createCache(seen);
+        if (cache) {
+          indexOf = cacheIndexOf;
+          seen = cache;
+        } else {
+          isLarge = false;
+          seen = callback ? seen : (releaseArray(seen), result);
+        }
       }
       while (++index < length) {
         var value = array[index],
             computed = callback ? callback(value, index, array) : value;
 
-        if (isLarge) {
-          var key = keyPrefix + computed;
-          var inited = cache[key]
-            ? !(seen = cache[key])
-            : (seen = cache[key] = []);
-        }
         if (isSorted
               ? !index || seen[seen.length - 1] !== computed
-              : inited || indexOf(seen, computed) < 0
+              : indexOf(seen, computed) < 0
             ) {
           if (callback || isLarge) {
             seen.push(computed);
@@ -4078,8 +4413,14 @@
           result.push(value);
         }
       }
+      if (isLarge) {
+        releaseArray(seen.array);
+        releaseObject(seen);
+      } else if (callback) {
+        releaseArray(seen);
+      }
       return result;
-    }
+    });
 
     /**
      * The inverse of `_.zip`, this method splits groups of elements into arrays
@@ -4097,17 +4438,11 @@
      */
     function unzip(array) {
       var index = -1,
-          length = array ? array.length : 0,
-          tupleLength = length ? max(pluck(array, 'length')) : 0,
-          result = Array(tupleLength);
+          length = array ? max(pluck(array, 'length')) : 0,
+          result = Array(length < 0 ? 0 : length);
 
       while (++index < length) {
-        var tupleIndex = -1,
-            tuple = array[index];
-
-        while (++tupleIndex < tupleLength) {
-          (result[tupleIndex] || (result[tupleIndex] = Array(length)))[index] = tuple[tupleIndex];
-        }
+        result[index] = pluck(array, index);
       }
       return result;
     }
@@ -4148,14 +4483,7 @@
      * // => [['moe', 30, true], ['larry', 40, false]]
      */
     function zip(array) {
-      var index = -1,
-          length = array ? max(pluck(arguments, 'length')) : 0,
-          result = Array(length);
-
-      while (++index < length) {
-        result[index] = pluck(arguments, index);
-      }
-      return result;
+      return array ? unzip(arguments) : [];
     }
 
     /**
@@ -4431,27 +4759,27 @@
           return result;
         };
       }
-      if (typeof thisArg != 'undefined') {
-        if (argCount === 1) {
-          return function(value) {
-            return func.call(thisArg, value);
-          };
-        }
-        if (argCount === 2) {
-          return function(a, b) {
-            return func.call(thisArg, a, b);
-          };
-        }
-        if (argCount === 4) {
-          return function(accumulator, value, index, collection) {
-            return func.call(thisArg, accumulator, value, index, collection);
-          };
-        }
-        return function(value, index, collection) {
-          return func.call(thisArg, value, index, collection);
+      if (typeof thisArg == 'undefined' || (reThis && !reThis.test(fnToString.call(func)))) {
+        return func;
+      }
+      if (argCount === 1) {
+        return function(value) {
+          return func.call(thisArg, value);
+        };
+      }
+      if (argCount === 2) {
+        return function(a, b) {
+          return func.call(thisArg, a, b);
         };
       }
-      return func;
+      if (argCount === 4) {
+        return function(accumulator, value, index, collection) {
+          return func.call(thisArg, accumulator, value, index, collection);
+        };
+      }
+      return function(value, index, collection) {
+        return func.call(thisArg, value, index, collection);
+      };
     }
 
     /**
@@ -4472,6 +4800,7 @@
      * @param {Number} wait The number of milliseconds to delay.
      * @param {Object} options The options object.
      *  [leading=false] A boolean to specify execution on the leading edge of the timeout.
+     *  [maxWait] The maximum time `func` is allowed to be delayed before it's called.
      *  [trailing=true] A boolean to specify execution on the trailing edge of the timeout.
      * @returns {Function} Returns the new debounced function.
      * @example
@@ -4486,34 +4815,80 @@
      */
     function debounce(func, wait, options) {
       var args,
-          inited,
           result,
           thisArg,
-          timeoutId,
+          callCount = 0,
+          lastCalled = 0,
+          maxWait = false,
+          maxTimeoutId = null,
+          timeoutId = null,
           trailing = true;
 
+      function clear() {
+        clearTimeout(maxTimeoutId);
+        clearTimeout(timeoutId);
+        callCount = 0;
+        maxTimeoutId = timeoutId = null;
+      }
+
       function delayed() {
-        inited = timeoutId = null;
-        if (trailing) {
+        var isCalled = trailing && (!leading || callCount > 1);
+        clear();
+        if (isCalled) {
+          if (maxWait !== false) {
+            lastCalled = new Date;
+          }
+          result = func.apply(thisArg, args);
+        }
+      }
+
+      function maxDelayed() {
+        clear();
+        if (trailing || (maxWait !== wait)) {
+          lastCalled = new Date;
           result = func.apply(thisArg, args);
         }
       }
+
+      wait = nativeMax(0, wait || 0);
       if (options === true) {
         var leading = true;
         trailing = false;
-      } else if (options && objectTypes[typeof options]) {
+      } else if (isObject(options)) {
         leading = options.leading;
+        maxWait = 'maxWait' in options && nativeMax(wait, options.maxWait || 0);
         trailing = 'trailing' in options ? options.trailing : trailing;
       }
       return function() {
         args = arguments;
         thisArg = this;
+        callCount++;
+
+        // avoid issues with Titanium and `undefined` timeout ids
+        // https://github.com/appcelerator/titanium_mobile/blob/3_1_0_GA/android/titanium/src/java/ti/modules/titanium/TitaniumModule.java#L185-L192
         clearTimeout(timeoutId);
 
-        if (!inited && leading) {
-          inited = true;
-          result = func.apply(thisArg, args);
+        if (maxWait === false) {
+          if (leading && callCount < 2) {
+            result = func.apply(thisArg, args);
+          }
         } else {
+          var now = new Date;
+          if (!maxTimeoutId && !leading) {
+            lastCalled = now;
+          }
+          var remaining = maxWait - (now - lastCalled);
+          if (remaining <= 0) {
+            clearTimeout(maxTimeoutId);
+            maxTimeoutId = null;
+            lastCalled = now;
+            result = func.apply(thisArg, args);
+          }
+          else if (!maxTimeoutId) {
+            maxTimeoutId = setTimeout(maxDelayed, remaining);
+          }
+        }
+        if (wait !== maxWait) {
           timeoutId = setTimeout(delayed, wait);
         }
         return result;
@@ -4571,7 +4946,8 @@
      * passed, it will be used to determine the cache key for storing the result
      * based on the arguments passed to the memoized function. By default, the first
      * argument passed to the memoized function is used as the cache key. The `func`
-     * is executed with the `this` binding of the memoized function.
+     * is executed with the `this` binding of the memoized function. The result
+     * cache is exposed as the `cache` property on the memoized function.
      *
      * @static
      * @memberOf _
@@ -4586,13 +4962,16 @@
      * });
      */
     function memoize(func, resolver) {
-      var cache = {};
-      return function() {
-        var key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);
+      function memoized() {
+        var cache = memoized.cache,
+            key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);
+
         return hasOwnProperty.call(cache, key)
           ? cache[key]
           : (cache[key] = func.apply(this, arguments));
-      };
+      }
+      memoized.cache = {};
+      return memoized;
     }
 
     /**
@@ -4712,47 +5091,23 @@
      * }));
      */
     function throttle(func, wait, options) {
-      var args,
-          result,
-          thisArg,
-          timeoutId,
-          lastCalled = 0,
-          leading = true,
+      var leading = true,
           trailing = true;
 
-      function trailingCall() {
-        timeoutId = null;
-        if (trailing) {
-          lastCalled = new Date;
-          result = func.apply(thisArg, args);
-        }
-      }
       if (options === false) {
         leading = false;
-      } else if (options && objectTypes[typeof options]) {
+      } else if (isObject(options)) {
         leading = 'leading' in options ? options.leading : leading;
         trailing = 'trailing' in options ? options.trailing : trailing;
       }
-      return function() {
-        var now = new Date;
-        if (!timeoutId && !leading) {
-          lastCalled = now;
-        }
-        var remaining = wait - (now - lastCalled);
-        args = arguments;
-        thisArg = this;
+      options = getObject();
+      options.leading = leading;
+      options.maxWait = wait;
+      options.trailing = trailing;
 
-        if (remaining <= 0) {
-          clearTimeout(timeoutId);
-          timeoutId = null;
-          lastCalled = now;
-          result = func.apply(thisArg, args);
-        }
-        else if (!timeoutId) {
-          timeoutId = setTimeout(trailingCall, remaining);
-        }
-        return result;
-      };
+      var result = debounce(func, wait, options);
+      releaseObject(options);
+      return result;
     }
 
     /**
@@ -4805,7 +5160,7 @@
     }
 
     /**
-     * This function returns the first argument passed to it.
+     * This method returns the first argument passed to it.
      *
      * @static
      * @memberOf _
@@ -4854,7 +5209,7 @@
 
           push.apply(args, arguments);
           var result = func.apply(lodash, args);
-          return (value && typeof value == 'object' && value == result)
+          return (value && typeof value == 'object' && value === result)
             ? this
             : new lodashWrapper(result);
         };
@@ -4928,8 +5283,13 @@
       if (max == null) {
         max = min;
         min = 0;
+      } else {
+        max = +max || 0;
       }
-      return min + floor(nativeRandom() * ((+max || 0) - min + 1));
+      var rand = nativeRandom();
+      return (min % 1 || max % 1)
+        ? min + nativeMin(rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1))), max)
+        : min + floor(rand * (max - min + 1));
     }
 
     /**
@@ -5332,6 +5692,7 @@
     lodash.throttle = throttle;
     lodash.times = times;
     lodash.toArray = toArray;
+    lodash.transform = transform;
     lodash.union = union;
     lodash.uniq = uniq;
     lodash.unzip = unzip;
@@ -5356,6 +5717,10 @@
     // add functions to `lodash.prototype`
     mixin(lodash);
 
+    // add Underscore compat
+    lodash.chain = lodash;
+    lodash.prototype.chain = function() { return this; };
+
     /*--------------------------------------------------------------------------*/
 
     // add functions that return unwrapped values when chaining
@@ -5407,6 +5772,7 @@
     lodash.all = every;
     lodash.any = some;
     lodash.detect = find;
+    lodash.findWhere = find;
     lodash.foldl = reduce;
     lodash.foldr = reduceRight;
     lodash.include = contains;
@@ -5452,7 +5818,7 @@
      * @memberOf _
      * @type String
      */
-    lodash.VERSION = '1.2.1';
+    lodash.VERSION = '1.3.1';
 
     // add "Chaining" functions to the wrapper
     lodash.prototype.toString = wrapperToString;
@@ -5460,7 +5826,7 @@
     lodash.prototype.valueOf = wrapperValueOf;
 
     // add `Array` functions that return unwrapped values
-    each(['join', 'pop', 'shift'], function(methodName) {
+    basicEach(['join', 'pop', 'shift'], function(methodName) {
       var func = arrayRef[methodName];
       lodash.prototype[methodName] = function() {
         return func.apply(this.__wrapped__, arguments);
@@ -5468,7 +5834,7 @@
     });
 
     // add `Array` functions that return the wrapped value
-    each(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+    basicEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
       var func = arrayRef[methodName];
       lodash.prototype[methodName] = function() {
         func.apply(this.__wrapped__, arguments);
@@ -5477,7 +5843,7 @@
     });
 
     // add `Array` functions that return new wrapped values
-    each(['concat', 'slice', 'splice'], function(methodName) {
+    basicEach(['concat', 'slice', 'splice'], function(methodName) {
       var func = arrayRef[methodName];
       lodash.prototype[methodName] = function() {
         return new lodashWrapper(func.apply(this.__wrapped__, arguments));
@@ -5487,7 +5853,7 @@
     // avoid array-like object bugs with `Array#shift` and `Array#splice`
     // in Firefox < 10 and IE < 9
     if (!support.spliceObjects) {
-      each(['pop', 'shift', 'splice'], function(methodName) {
+      basicEach(['pop', 'shift', 'splice'], function(methodName) {
         var func = arrayRef[methodName],
             isSplice = methodName == 'splice';