3  * Lo-Dash 2.4.2 (Custom Build) <https://lodash.com/>

     3  * lodash 3.10.1 (Custom Build) <https://lodash.com/>

     4  * Build: `lodash modern -o ./dist/lodash.js`

     4  * Build: `lodash modern -o ./lodash.js`

     5  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>

     5  * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>

     6  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>

     6  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>

     7  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

     7  * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

    12   /** Used as a safe reference for `undefined` in pre ES5 environments */

    12   /** Used as a safe reference for `undefined` in pre-ES5 environments. */

    15   /** Used to pool arrays and objects used internally */

    15   /** Used as the semantic version number. */

    16   var arrayPool = [],

    16   var VERSION = '3.10.1';

    17       objectPool = [];

    17 

    18 

    18   /** Used to compose bitmasks for wrapper metadata. */

    19   /** Used to generate unique IDs */

    19   var BIND_FLAG = 1,

    20   var idCounter = 0;

    20       BIND_KEY_FLAG = 2,

    21 

    21       CURRY_BOUND_FLAG = 4,

    22   /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */

    22       CURRY_FLAG = 8,

    23   var keyPrefix = +new Date + '';

    23       CURRY_RIGHT_FLAG = 16,

    24 

    24       PARTIAL_FLAG = 32,

    25   /** Used as the size when optimizations are enabled for large arrays */

    25       PARTIAL_RIGHT_FLAG = 64,

    26   var largeArraySize = 75;

    26       ARY_FLAG = 128,

    27 

    27       REARG_FLAG = 256;

    28   /** Used as the max size of the `arrayPool` and `objectPool` */

    28 

    29   var maxPoolSize = 40;

    29   /** Used as default options for `_.trunc`. */

    30 

    30   var DEFAULT_TRUNC_LENGTH = 30,

    31   /** Used to detect and test whitespace */

    31       DEFAULT_TRUNC_OMISSION = '...';

    32   var whitespace = (

    32 

    33     // whitespace

    33   /** Used to detect when a function becomes hot. */

    34     ' \t\x0B\f\xA0\ufeff' +

    34   var HOT_COUNT = 150,

    35 

    35       HOT_SPAN = 16;

    36     // line terminators

    36 

    37     '\n\r\u2028\u2029' +

    37   /** Used as the size to enable large array optimizations. */

    38 

    38   var LARGE_ARRAY_SIZE = 200;

    39     // unicode category "Zs" space separators

    39 

    40     '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'

    40   /** Used to indicate the type of lazy iteratees. */

    41   );

    41   var LAZY_FILTER_FLAG = 1,

    42 

    42       LAZY_MAP_FLAG = 2;

    43   /** Used to match empty string literals in compiled template source */

    43 

    44   /** Used as the `TypeError` message for "Functions" methods. */

    45   var FUNC_ERROR_TEXT = 'Expected a function';

    46 

    47   /** Used as the internal argument placeholder. */

    48   var PLACEHOLDER = '__lodash_placeholder__';

    49 

    50   /** `Object#toString` result references. */

    51   var argsTag = '[object Arguments]',

    52       arrayTag = '[object Array]',

    53       boolTag = '[object Boolean]',

    54       dateTag = '[object Date]',

    55       errorTag = '[object Error]',

    56       funcTag = '[object Function]',

    57       mapTag = '[object Map]',

    58       numberTag = '[object Number]',

    59       objectTag = '[object Object]',

    60       regexpTag = '[object RegExp]',

    61       setTag = '[object Set]',

    62       stringTag = '[object String]',

    63       weakMapTag = '[object WeakMap]';

    64 

    65   var arrayBufferTag = '[object ArrayBuffer]',

    66       float32Tag = '[object Float32Array]',

    67       float64Tag = '[object Float64Array]',

    68       int8Tag = '[object Int8Array]',

    69       int16Tag = '[object Int16Array]',

    70       int32Tag = '[object Int32Array]',

    71       uint8Tag = '[object Uint8Array]',

    72       uint8ClampedTag = '[object Uint8ClampedArray]',

    73       uint16Tag = '[object Uint16Array]',

    74       uint32Tag = '[object Uint32Array]';

    75 

    76   /** Used to match empty string literals in compiled template source. */

    49    * Used to match ES6 template delimiters

    98    * Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns)

    50    * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals

    99    * and those outlined by [`EscapeRegExpPattern`](http://ecma-international.org/ecma-262/6.0/#sec-escaperegexppattern).

    54   /** Used to match regexp flags from their coerced string values */

   113   /** Used to match `RegExp` flags from their coerced string values. */

    57   /** Used to detected named functions */

   116   /** Used to detect hexadecimal string values. */

    58   var reFuncName = /^\s*function[ \n\r\t]+\w/;

   117   var reHasHexPrefix = /^0[xX]/;

    59 

   118 

    60   /** Used to match "interpolate" template delimiters */

   119   /** Used to detect host constructors (Safari > 5). */

    61   var reInterpolate = /<%=([\s\S]+?)%>/g;

   120   var reIsHostCtor = /^\[object .+?Constructor\]$/;

    62 

   121 

    63   /** Used to match leading whitespace and zeros to be removed */

   122   /** Used to detect unsigned integer values. */

    64   var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');

   123   var reIsUint = /^\d+$/;

    65 

   124 

    66   /** Used to ensure capturing order of template delimiters */

   125   /** Used to match latin-1 supplementary letters (excluding mathematical operators). */

   126   var reLatin1 = /[\xc0-\xd6\xd8-\xde\xdf-\xf6\xf8-\xff]/g;

   127 

   128   /** Used to ensure capturing order of template delimiters. */

    69   /** Used to detect functions containing a `this` reference */

   131   /** Used to match unescaped characters in compiled string literals. */

    70   var reThis = /\bthis\b/;

   132   var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

    71 

   133 

    72   /** Used to match unescaped characters in compiled string literals */

   134   /** Used to match words to create compound words. */

    73   var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;

   135   var reWords = (function() {

    74 

   136     var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]',

    75   /** Used to assign default `context` object properties */

   137         lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+';

   138 

   139     return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g');

   140   }());

   141 

   142   /** Used to assign default `context` object properties. */

    77     'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',

   144     'Array', 'ArrayBuffer', 'Date', 'Error', 'Float32Array', 'Float64Array',

    78     'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',

   145     'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Math', 'Number',

    79     'parseInt', 'setTimeout'

   146     'Object', 'RegExp', 'Set', 'String', '_', 'clearTimeout', 'isFinite',

   147     'parseFloat', 'parseInt', 'setTimeout', 'TypeError', 'Uint8Array',

   148     'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap'

    82   /** Used to make template sourceURLs easier to identify */

   151   /** Used to make template sourceURLs easier to identify. */

    83   var templateCounter = 0;

   152   var templateCounter = -1;

    84 

   153 

    85   /** `Object#toString` result shortcuts */

   154   /** Used to identify `toStringTag` values of typed arrays. */

    86   var argsClass = '[object Arguments]',

   155   var typedArrayTags = {};

    87       arrayClass = '[object Array]',

   156   typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

    88       boolClass = '[object Boolean]',

   157   typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

    89       dateClass = '[object Date]',

   158   typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

    90       funcClass = '[object Function]',

   159   typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

    91       numberClass = '[object Number]',

   160   typedArrayTags[uint32Tag] = true;

    92       objectClass = '[object Object]',

   161   typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

    93       regexpClass = '[object RegExp]',

   162   typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

    94       stringClass = '[object String]';

   163   typedArrayTags[dateTag] = typedArrayTags[errorTag] =

    95 

   164   typedArrayTags[funcTag] = typedArrayTags[mapTag] =

    96   /** Used to identify object classifications that `_.clone` supports */

   165   typedArrayTags[numberTag] = typedArrayTags[objectTag] =

    97   var cloneableClasses = {};

   166   typedArrayTags[regexpTag] = typedArrayTags[setTag] =

    98   cloneableClasses[funcClass] = false;

   167   typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

    99   cloneableClasses[argsClass] = cloneableClasses[arrayClass] =

   168 

   100   cloneableClasses[boolClass] = cloneableClasses[dateClass] =

   169   /** Used to identify `toStringTag` values supported by `_.clone`. */

   101   cloneableClasses[numberClass] = cloneableClasses[objectClass] =

   170   var cloneableTags = {};

   102   cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;

   171   cloneableTags[argsTag] = cloneableTags[arrayTag] =

   103 

   172   cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =

   104   /** Used as an internal `_.debounce` options object */

   173   cloneableTags[dateTag] = cloneableTags[float32Tag] =

   105   var debounceOptions = {

   174   cloneableTags[float64Tag] = cloneableTags[int8Tag] =

   106     'leading': false,

   175   cloneableTags[int16Tag] = cloneableTags[int32Tag] =

   107     'maxWait': 0,

   176   cloneableTags[numberTag] = cloneableTags[objectTag] =

   108     'trailing': false

   177   cloneableTags[regexpTag] = cloneableTags[stringTag] =

   178   cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

   179   cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

   180   cloneableTags[errorTag] = cloneableTags[funcTag] =

   181   cloneableTags[mapTag] = cloneableTags[setTag] =

   182   cloneableTags[weakMapTag] = false;

   183 

   184   /** Used to map latin-1 supplementary letters to basic latin letters. */

   185   var deburredLetters = {

   186     '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

   187     '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

   188     '\xc7': 'C',  '\xe7': 'c',

   189     '\xd0': 'D',  '\xf0': 'd',

   190     '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

   191     '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

   192     '\xcC': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

   193     '\xeC': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',

   194     '\xd1': 'N',  '\xf1': 'n',

   195     '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

   196     '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

   197     '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

   198     '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

   199     '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',

   200     '\xc6': 'Ae', '\xe6': 'ae',

   201     '\xde': 'Th', '\xfe': 'th',

   202     '\xdf': 'ss'

   111   /** Used as the property descriptor for `__bindData__` */

   205   /** Used to map characters to HTML entities. */

   112   var descriptor = {

   206   var htmlEscapes = {

   113     'configurable': false,

   207     '&': '&',

   114     'enumerable': false,

   208     '<': '&lt;',

   115     'value': null,

   209     '>': '>',

   116     'writable': false

   210     '"': '"',

   211     "'": ''',

   212     '`': '`'

   119   /** Used to determine if values are of the language type Object */

   215   /** Used to map HTML entities to characters. */

   216   var htmlUnescapes = {

   217     '&': '&',

   218     '&lt;': '<',

   219     '>': '>',

   220     '"': '"',

   221     ''': "'",

   222     '`': '`'

   223   };

   224 

   225   /** Used to determine if values are of the language type `Object`. */

   123     'object': true,

   228     'object': true

   124     'number': false,

   125     'string': false,

   126     'undefined': false

   129   /** Used to escape characters for inclusion in compiled string literals */

   231   /** Used to escape characters for inclusion in compiled regexes. */

   232   var regexpEscapes = {

   233     '0': 'x30', '1': 'x31', '2': 'x32', '3': 'x33', '4': 'x34',

   234     '5': 'x35', '6': 'x36', '7': 'x37', '8': 'x38', '9': 'x39',

   235     'A': 'x41', 'B': 'x42', 'C': 'x43', 'D': 'x44', 'E': 'x45', 'F': 'x46',

   236     'a': 'x61', 'b': 'x62', 'c': 'x63', 'd': 'x64', 'e': 'x65', 'f': 'x66',

   237     'n': 'x6e', 'r': 'x72', 't': 'x74', 'u': 'x75', 'v': 'x76', 'x': 'x78'

   238   };

   239 

   240   /** Used to escape characters for inclusion in compiled string literals. */

   140   /** Used as a reference to the global object */

   250   /** Detect free variable `exports`. */

   141   var root = (objectTypes[typeof window] && window) || this;

   142 

   143   /** Detect free variable `exports` */

   146   /** Detect free variable `module` */

   253   /** Detect free variable `module`. */

   149   /** Detect the popular CommonJS extension `module.exports` */

   256   /** Detect free variable `global` from Node.js. */

   257   var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;

   258 

   259   /** Detect free variable `self`. */

   260   var freeSelf = objectTypes[typeof self] && self && self.Object && self;

   261 

   262   /** Detect free variable `window`. */

   263   var freeWindow = objectTypes[typeof window] && window && window.Object && window;

   264 

   265   /** Detect the popular CommonJS extension `module.exports`. */

   152   /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */

   268   /**

   153   var freeGlobal = objectTypes[typeof global] && global;

   269    * Used as a reference to the global object.

   154   if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {

   270    *

   155     root = freeGlobal;

   271    * The `this` value is used if it's the global object to avoid Greasemonkey's

   272    * restricted `window` object, otherwise the `window` object is used.

   273    */

   274   var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;

   275 

   276   /*--------------------------------------------------------------------------*/

   277 

   278   /**

   279    * The base implementation of `compareAscending` which compares values and

   280    * sorts them in ascending order without guaranteeing a stable sort.

   281    *

   282    * @private

   283    * @param {*} value The value to compare.

   284    * @param {*} other The other value to compare.

   285    * @returns {number} Returns the sort order indicator for `value`.

   286    */

   287   function baseCompareAscending(value, other) {

   288     if (value !== other) {

   289       var valIsNull = value === null,

   290           valIsUndef = value === undefined,

   291           valIsReflexive = value === value;

   292 

   293       var othIsNull = other === null,

   294           othIsUndef = other === undefined,

   295           othIsReflexive = other === other;

   296 

   297       if ((value > other && !othIsNull) || !valIsReflexive ||

   298           (valIsNull && !othIsUndef && othIsReflexive) ||

   299           (valIsUndef && othIsReflexive)) {

   300         return 1;

   301       }

   302       if ((value < other && !valIsNull) || !othIsReflexive ||

   303           (othIsNull && !valIsUndef && valIsReflexive) ||

   304           (othIsUndef && valIsReflexive)) {

   305         return -1;

   306       }

   307     }

   308     return 0;

   161    * The base implementation of `_.indexOf` without support for binary searches

   312    * The base implementation of `_.findIndex` and `_.findLastIndex` without

   162    * or `fromIndex` constraints.

   313    * support for callback shorthands and `this` binding.

   314    *

   315    * @private

   316    * @param {Array} array The array to search.

   317    * @param {Function} predicate The function invoked per iteration.

   318    * @param {boolean} [fromRight] Specify iterating from right to left.

   319    * @returns {number} Returns the index of the matched value, else `-1`.

   320    */

   321   function baseFindIndex(array, predicate, fromRight) {

   322     var length = array.length,

   323         index = fromRight ? length : -1;

   324 

   325     while ((fromRight ? index-- : ++index < length)) {

   326       if (predicate(array[index], index, array)) {

   327         return index;

   328       }

   329     }

   330     return -1;

   331   }

   332 

   333   /**

   334    * The base implementation of `_.indexOf` without support for binary searches.

   167    * @param {number} [fromIndex=0] The index to search from.

   339    * @param {number} fromIndex The index to search from.

   168    * @returns {number} Returns the index of the matched value or `-1`.

   340    * @returns {number} Returns the index of the matched value, else `-1`.

   171     var index = (fromIndex || 0) - 1,

   343     if (value !== value) {

   172         length = array ? array.length : 0;

   344       return indexOfNaN(array, fromIndex);

   345     }

   346     var index = fromIndex - 1,

   347         length = array.length;

   183    * An implementation of `_.contains` for cache objects that mimics the return

   358    * The base implementation of `_.isFunction` without support for environments

   184    * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.

   359    * with incorrect `typeof` results.

   187    * @param {Object} cache The cache object to inspect.

   362    * @param {*} value The value to check.

   188    * @param {*} value The value to search for.

   363    * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.

   189    * @returns {number} Returns `0` if `value` is found, else `-1`.

   191   function cacheIndexOf(cache, value) {

   365   function baseIsFunction(value) {

   192     var type = typeof value;

   366     // Avoid a Chakra JIT bug in compatibility modes of IE 11.

   193     cache = cache.cache;

   367     // See https://github.com/jashkenas/underscore/issues/1621 for more details.

   194 

   368     return typeof value == 'function' || false;

   195     if (type == 'boolean' || value == null) {

   196       return cache[value] ? 0 : -1;

   197     }

   198     if (type != 'number' && type != 'string') {

   199       type = 'object';

   200     }

   201     var key = type == 'number' ? value : keyPrefix + value;

   202     cache = (cache = cache[type]) && cache[key];

   203 

   204     return type == 'object'

   205       ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)

   206       : (cache ? 0 : -1);

   210    * Adds a given value to the corresponding cache object.

   372    * Converts `value` to a string if it's not one. An empty string is returned

   373    * for `null` or `undefined` values.

   213    * @param {*} value The value to add to the cache.

   376    * @param {*} value The value to process.

   377    * @returns {string} Returns the string.

   215   function cachePush(value) {

   379   function baseToString(value) {

   216     var cache = this.cache,

   380     return value == null ? '' : (value + '');

   217         type = typeof value;

   218 

   219     if (type == 'boolean' || value == null) {

   220       cache[value] = true;

   221     } else {

   222       if (type != 'number' && type != 'string') {

   223         type = 'object';

   224       }

   225       var key = type == 'number' ? value : keyPrefix + value,

   226           typeCache = cache[type] || (cache[type] = {});

   227 

   228       if (type == 'object') {

   229         (typeCache[key] || (typeCache[key] = [])).push(value);

   230       } else {

   231         typeCache[key] = true;

   232       }

   233     }

   237    * Used by `_.max` and `_.min` as the default callback when a given

   384    * Used by `_.trim` and `_.trimLeft` to get the index of the first character

   238    * collection is a string value.

   385    * of `string` that is not found in `chars`.

   241    * @param {string} value The character to inspect.

   388    * @param {string} string The string to inspect.

   242    * @returns {number} Returns the code unit of given character.

   389    * @param {string} chars The characters to find.

   390    * @returns {number} Returns the index of the first character not found in `chars`.

   244   function charAtCallback(value) {

   392   function charsLeftIndex(string, chars) {

   245     return value.charCodeAt(0);

   393     var index = -1,

   394         length = string.length;

   395 

   396     while (++index < length && chars.indexOf(string.charAt(index)) > -1) {}

   397     return index;

   249    * Used by `sortBy` to compare transformed `collection` elements, stable sorting

   401    * Used by `_.trim` and `_.trimRight` to get the index of the last character

   250    * them in ascending order.

   402    * of `string` that is not found in `chars`.

   253    * @param {Object} a The object to compare to `b`.

   405    * @param {string} string The string to inspect.

   254    * @param {Object} b The object to compare to `a`.

   406    * @param {string} chars The characters to find.

   255    * @returns {number} Returns the sort order indicator of `1` or `-1`.

   407    * @returns {number} Returns the index of the last character not found in `chars`.

   257   function compareAscending(a, b) {

   409   function charsRightIndex(string, chars) {

   258     var ac = a.criteria,

   410     var index = string.length;

   259         bc = b.criteria,

   411 

   260         index = -1,

   412     while (index-- && chars.indexOf(string.charAt(index)) > -1) {}

   261         length = ac.length;

   413     return index;

   414   }

   415 

   416   /**

   417    * Used by `_.sortBy` to compare transformed elements of a collection and stable

   418    * sort them in ascending order.

   419    *

   420    * @private

   421    * @param {Object} object The object to compare.

   422    * @param {Object} other The other object to compare.

   423    * @returns {number} Returns the sort order indicator for `object`.

   424    */

   425   function compareAscending(object, other) {

   426     return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);

   427   }

   428 

   429   /**

   430    * Used by `_.sortByOrder` to compare multiple properties of a value to another

   431    * and stable sort them.

   432    *

   433    * If `orders` is unspecified, all valuess are sorted in ascending order. Otherwise,

   434    * a value is sorted in ascending order if its corresponding order is "asc", and

   435    * descending if "desc".

   436    *

   437    * @private

   438    * @param {Object} object The object to compare.

   439    * @param {Object} other The other object to compare.

   440    * @param {boolean[]} orders The order to sort by for each property.

   441    * @returns {number} Returns the sort order indicator for `object`.

   442    */

   443   function compareMultiple(object, other, orders) {

   444     var index = -1,

   445         objCriteria = object.criteria,

   446         othCriteria = other.criteria,

   447         length = objCriteria.length,

   448         ordersLength = orders.length;

   264       var value = ac[index],

   451       var result = baseCompareAscending(objCriteria[index], othCriteria[index]);

   265           other = bc[index];

   452       if (result) {

   266 

   453         if (index >= ordersLength) {

   267       if (value !== other) {

   454           return result;

   268         if (value > other || typeof value == 'undefined') {

   455         }

   269           return 1;

   456         var order = orders[index];

   270         }

   457         return result * ((order === 'asc' || order === true) ? 1 : -1);

   271         if (value < other || typeof other == 'undefined') {

   272           return -1;

   273         }

   277     // that causes it, under certain circumstances, to return the same value for

   461     // that causes it, under certain circumstances, to provide the same value for

   278     // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247

   462     // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247

   463     // for more details.

   281     // See http://code.google.com/p/v8/issues/detail?id=90

   466     // See https://code.google.com/p/v8/issues/detail?id=90 for more details.

   282     return a.index - b.index;

   467     return object.index - other.index;

   286    * Creates a cache object to optimize linear searches of large arrays.

   471    * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters.

   289    * @param {Array} [array=[]] The array to search.

   474    * @param {string} letter The matched letter to deburr.

   290    * @returns {null|Object} Returns the cache object or `null` if caching should not be used.

   475    * @returns {string} Returns the deburred letter.

   292   function createCache(array) {

   477   function deburrLetter(letter) {

   478     return deburredLetters[letter];

   479   }

   480 

   481   /**

   482    * Used by `_.escape` to convert characters to HTML entities.

   483    *

   484    * @private

   485    * @param {string} chr The matched character to escape.

   486    * @returns {string} Returns the escaped character.

   487    */

   488   function escapeHtmlChar(chr) {

   489     return htmlEscapes[chr];

   490   }

   491 

   492   /**

   493    * Used by `_.escapeRegExp` to escape characters for inclusion in compiled regexes.

   494    *

   495    * @private

   496    * @param {string} chr The matched character to escape.

   497    * @param {string} leadingChar The capture group for a leading character.

   498    * @param {string} whitespaceChar The capture group for a whitespace character.

   499    * @returns {string} Returns the escaped character.

   500    */

   501   function escapeRegExpChar(chr, leadingChar, whitespaceChar) {

   502     if (leadingChar) {

   503       chr = regexpEscapes[chr];

   504     } else if (whitespaceChar) {

   505       chr = stringEscapes[chr];

   506     }

   507     return '\\' + chr;

   508   }

   509 

   510   /**

   511    * Used by `_.template` to escape characters for inclusion in compiled string literals.

   512    *

   513    * @private

   514    * @param {string} chr The matched character to escape.

   515    * @returns {string} Returns the escaped character.

   516    */

   517   function escapeStringChar(chr) {

   518     return '\\' + stringEscapes[chr];

   519   }

   520 

   521   /**

   522    * Gets the index at which the first occurrence of `NaN` is found in `array`.

   523    *

   524    * @private

   525    * @param {Array} array The array to search.

   526    * @param {number} fromIndex The index to search from.

   527    * @param {boolean} [fromRight] Specify iterating from right to left.

   528    * @returns {number} Returns the index of the matched `NaN`, else `-1`.

   529    */

   530   function indexOfNaN(array, fromIndex, fromRight) {

   531     var length = array.length,

   532         index = fromIndex + (fromRight ? 0 : -1);

   533 

   534     while ((fromRight ? index-- : ++index < length)) {

   535       var other = array[index];

   536       if (other !== other) {

   537         return index;

   538       }

   539     }

   540     return -1;

   541   }

   542 

   543   /**

   544    * Checks if `value` is object-like.

   545    *

   546    * @private

   547    * @param {*} value The value to check.

   548    * @returns {boolean} Returns `true` if `value` is object-like, else `false`.

   549    */

   550   function isObjectLike(value) {

   551     return !!value && typeof value == 'object';

   552   }

   553 

   554   /**

   555    * Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a

   556    * character code is whitespace.

   557    *

   558    * @private

   559    * @param {number} charCode The character code to inspect.

   560    * @returns {boolean} Returns `true` if `charCode` is whitespace, else `false`.

   561    */

   562   function isSpace(charCode) {

   563     return ((charCode <= 160 && (charCode >= 9 && charCode <= 13) || charCode == 32 || charCode == 160) || charCode == 5760 || charCode == 6158 ||

   564       (charCode >= 8192 && (charCode <= 8202 || charCode == 8232 || charCode == 8233 || charCode == 8239 || charCode == 8287 || charCode == 12288 || charCode == 65279)));

   565   }

   566 

   567   /**

   568    * Replaces all `placeholder` elements in `array` with an internal placeholder

   569    * and returns an array of their indexes.

   570    *

   571    * @private

   572    * @param {Array} array The array to modify.

   573    * @param {*} placeholder The placeholder to replace.

   574    * @returns {Array} Returns the new array of placeholder indexes.

   575    */

   576   function replaceHolders(array, placeholder) {

   295         first = array[0],

   579         resIndex = -1,

   296         mid = array[(length / 2) | 0],

   580         result = [];

   297         last = array[length - 1];

   298 

   299     if (first && typeof first == 'object' &&

   300         mid && typeof mid == 'object' && last && typeof last == 'object') {

   301       return false;

   302     }

   303     var cache = getObject();

   304     cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;

   305 

   306     var result = getObject();

   307     result.array = array;

   308     result.cache = cache;

   309     result.push = cachePush;

   312       result.push(array[index]);

   583       if (array[index] === placeholder) {

   584         array[index] = PLACEHOLDER;

   585         result[++resIndex] = index;

   586       }

   318    * Used by `template` to escape characters for inclusion in compiled

   592    * An implementation of `_.uniq` optimized for sorted arrays without support

   319    * string literals.

   593    * for callback shorthands and `this` binding.

   322    * @param {string} match The matched character to escape.

   596    * @param {Array} array The array to inspect.

   323    * @returns {string} Returns the escaped character.

   597    * @param {Function} [iteratee] The function invoked per iteration.

   598    * @returns {Array} Returns the new duplicate free array.

   325   function escapeStringChar(match) {

   600   function sortedUniq(array, iteratee) {

   326     return '\\' + stringEscapes[match];

   601     var seen,

   602         index = -1,

   603         length = array.length,

   604         resIndex = -1,

   605         result = [];

   606 

   607     while (++index < length) {

   608       var value = array[index],

   609           computed = iteratee ? iteratee(value, index, array) : value;

   610 

   611       if (!index || seen !== computed) {

   612         seen = computed;

   613         result[++resIndex] = value;

   614       }

   615     }

   616     return result;

   330    * Gets an array from the array pool or creates a new one if the pool is empty.

   620    * Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace

   621    * character of `string`.

   333    * @returns {Array} The array from the pool.

   624    * @param {string} string The string to inspect.

   625    * @returns {number} Returns the index of the first non-whitespace character.

   335   function getArray() {

   627   function trimmedLeftIndex(string) {

   336     return arrayPool.pop() || [];

   628     var index = -1,

   629         length = string.length;

   630 

   631     while (++index < length && isSpace(string.charCodeAt(index))) {}

   632     return index;

   340    * Gets an object from the object pool or creates a new one if the pool is empty.

   636    * Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace

   637    * character of `string`.

   343    * @returns {Object} The object from the pool.

   640    * @param {string} string The string to inspect.

   641    * @returns {number} Returns the index of the last non-whitespace character.

   345   function getObject() {

   643   function trimmedRightIndex(string) {

   346     return objectPool.pop() || {

   644     var index = string.length;

   347       'array': null,

   645 

   348       'cache': null,

   646     while (index-- && isSpace(string.charCodeAt(index))) {}

   349       'criteria': null,

   647     return index;

   350       'false': false,

   351       'index': 0,

   352       'null': false,

   353       'number': null,

   354       'object': null,

   355       'push': null,

   356       'string': null,

   357       'true': false,

   358       'undefined': false,

   359       'value': null

   360     };

   364    * Releases the given array back to the array pool.

   651    * Used by `_.unescape` to convert HTML entities to characters.

   367    * @param {Array} [array] The array to release.

   654    * @param {string} chr The matched character to unescape.

   655    * @returns {string} Returns the unescaped character.

   369   function releaseArray(array) {

   657   function unescapeHtmlChar(chr) {

   370     array.length = 0;

   658     return htmlUnescapes[chr];

   371     if (arrayPool.length < maxPoolSize) {

   372       arrayPool.push(array);

   373     }

   377    * Releases the given object back to the object pool.

   664    * Create a new pristine `lodash` function using the given `context` object.

   378    *

   379    * @private

   380    * @param {Object} [object] The object to release.

   381    */

   382   function releaseObject(object) {

   383     var cache = object.cache;

   384     if (cache) {

   385       releaseObject(cache);

   386     }

   387     object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;

   388     if (objectPool.length < maxPoolSize) {

   389       objectPool.push(object);

   390     }

   391   }

   392 

   393   /**

   394    * Slices the `collection` from the `start` index up to, but not including,

   395    * the `end` index.

   396    *

   397    * Note: This function is used instead of `Array#slice` to support node lists

   398    * in IE < 9 and to ensure dense arrays are returned.

   399    *

   400    * @private

   401    * @param {Array|Object|string} collection The collection to slice.

   402    * @param {number} start The start index.

   403    * @param {number} end The end index.

   404    * @returns {Array} Returns the new array.

   405    */

   406   function slice(array, start, end) {

   407     start || (start = 0);

   408     if (typeof end == 'undefined') {

   409       end = array ? array.length : 0;

   410     }

   411     var index = -1,

   412         length = end - start || 0,

   413         result = Array(length < 0 ? 0 : length);

   414 

   415     while (++index < length) {

   416       result[index] = array[start + index];

   417     }

   418     return result;

   419   }

   420 

   421   /*--------------------------------------------------------------------------*/

   422 

   423   /**

   424    * Create a new `lodash` function using the given context object.

   428    * @category Utilities

   668    * @category Utility

   430    * @returns {Function} Returns the `lodash` function.

   670    * @returns {Function} Returns a new `lodash` function.

   671    * @example

   672    *

   673    * _.mixin({ 'foo': _.constant('foo') });

   674    *

   675    * var lodash = _.runInContext();

   676    * lodash.mixin({ 'bar': lodash.constant('bar') });

   677    *

   678    * _.isFunction(_.foo);

   679    * // => true

   680    * _.isFunction(_.bar);

   681    * // => false

   682    *

   683    * lodash.isFunction(lodash.foo);

   684    * // => false

   685    * lodash.isFunction(lodash.bar);

   686    * // => true

   687    *

   688    * // using `context` to mock `Date#getTime` use in `_.now`

   689    * var mock = _.runInContext({

   690    *   'Date': function() {

   691    *     return { 'getTime': getTimeMock };

   692    *   }

   693    * });

   694    *

   695    * // or creating a suped-up `defer` in Node.js

   696    * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;

   436     // See http://es5.github.io/#x11.1.5.

   702     // See https://es5.github.io/#x11.1.5 for more details.

   439     /** Native constructor references */

   705     /** Native constructor references. */

   451     /**

   717     /** Used for native method references. */

   452      * Used for `Array` method references.

   718     var arrayProto = Array.prototype,

   453      *

   719         objectProto = Object.prototype,

   454      * Normally `Array.prototype` would suffice, however, using an array literal

   720         stringProto = String.prototype;

   455      * avoids issues in Narwhal.

   721 

   456      */

   722     /** Used to resolve the decompiled source of functions. */

   457     var arrayRef = [];

   723     var fnToString = Function.prototype.toString;

   458 

   724 

   459     /** Used for native method references */

   725     /** Used to check objects for own properties. */

   460     var objectProto = Object.prototype;

   726     var hasOwnProperty = objectProto.hasOwnProperty;

   461 

   727 

   462     /** Used to restore the original `_` reference in `noConflict` */

   728     /** Used to generate unique IDs. */

   463     var oldDash = context._;

   729     var idCounter = 0;

   464 

   730 

   465     /** Used to resolve the internal [[Class]] of values */

   731     /**

   466     var toString = objectProto.toString;

   732      * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)

   467 

   733      * of values.

   468     /** Used to detect if a method is native */

   734      */

   469     var reNative = RegExp('^' +

   735     var objToString = objectProto.toString;

   470       String(toString)

   736 

   471         .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

   737     /** Used to restore the original `_` reference in `_.noConflict`. */

   472         .replace(/toString| for [^\]]+/g, '.*?') + '$'

   738     var oldDash = root._;

   739 

   740     /** Used to detect if a method is native. */

   741     var reIsNative = RegExp('^' +

   742       fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')

   743       .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'

   475     /** Native method shortcuts */

   746     /** Native method references. */

   476     var ceil = Math.ceil,

   747     var ArrayBuffer = context.ArrayBuffer,

   478         floor = Math.floor,

   749         parseFloat = context.parseFloat,

   479         fnToString = Function.prototype.toString,

   750         pow = Math.pow,

   480         getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,

   751         propertyIsEnumerable = objectProto.propertyIsEnumerable,

   481         hasOwnProperty = objectProto.hasOwnProperty,

   752         Set = getNative(context, 'Set'),

   482         push = arrayRef.push,

   484         splice = arrayRef.splice,

   754         splice = arrayProto.splice,

   485         unshift = arrayRef.unshift;

   755         Uint8Array = context.Uint8Array,

   486 

   756         WeakMap = getNative(context, 'WeakMap');

   487     /** Used to set meta data on functions */

   757 

   488     var defineProperty = (function() {

   758     /* Native method references for those with the same name as other `lodash` methods. */

   489       // IE 8 only accepts DOM elements

   759     var nativeCeil = Math.ceil,

   490       try {

   760         nativeCreate = getNative(Object, 'create'),

   491         var o = {},

   761         nativeFloor = Math.floor,

   492             func = isNative(func = Object.defineProperty) && func,

   762         nativeIsArray = getNative(Array, 'isArray'),

   493             result = func(o, o, o) && func;

   494       } catch(e) { }

   495       return result;

   496     }());

   497 

   498     /* Native method shortcuts for methods with the same name as other `lodash` methods */

   499     var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,

   500         nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,

   502         nativeIsNaN = context.isNaN,

   764         nativeKeys = getNative(Object, 'keys'),

   503         nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,

   509     /** Used to lookup a built-in constructor by [[Class]] */

   771     /** Used as references for `-Infinity` and `Infinity`. */

   510     var ctorByClass = {};

   772     var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY,

   511     ctorByClass[arrayClass] = Array;

   773         POSITIVE_INFINITY = Number.POSITIVE_INFINITY;

   512     ctorByClass[boolClass] = Boolean;

   774 

   513     ctorByClass[dateClass] = Date;

   775     /** Used as references for the maximum length and index of an array. */

   514     ctorByClass[funcClass] = Function;

   776     var MAX_ARRAY_LENGTH = 4294967295,

   515     ctorByClass[objectClass] = Object;

   777         MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,

   516     ctorByClass[numberClass] = Number;

   778         HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

   517     ctorByClass[regexpClass] = RegExp;

   779 

   518     ctorByClass[stringClass] = String;

   780     /**

   519 

   781      * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)

   520     /*--------------------------------------------------------------------------*/

   782      * of an array-like value.

   521 

   783      */

   522     /**

   784     var MAX_SAFE_INTEGER = 9007199254740991;

   523      * Creates a `lodash` object which wraps the given value to enable intuitive

   785 

   524      * method chaining.

   786     /** Used to store function metadata. */

   525      *

   787     var metaMap = WeakMap && new WeakMap;

   526      * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:

   788 

   527      * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,

   789     /** Used to lookup unminified function names. */

   528      * and `unshift`

   790     var realNames = {};

   529      *

   791 

   530      * Chaining is supported in custom builds as long as the `value` method is

   792     /*------------------------------------------------------------------------*/

   531      * implicitly or explicitly included in the build.

   793 

   532      *

   794     /**

   533      * The chainable wrapper functions are:

   795      * Creates a `lodash` object which wraps `value` to enable implicit chaining.

   534      * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,

   796      * Methods that operate on and return arrays, collections, and functions can

   535      * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`,

   797      * be chained together. Methods that retrieve a single value or may return a

   536      * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`,

   798      * primitive value will automatically end the chain returning the unwrapped

   799      * value. Explicit chaining may be enabled using `_.chain`. The execution of

   800      * chained methods is lazy, that is, execution is deferred until `_#value`

   801      * is implicitly or explicitly called.

   802      *

   803      * Lazy evaluation allows several methods to support shortcut fusion. Shortcut

   804      * fusion is an optimization strategy which merge iteratee calls; this can help

   805      * to avoid the creation of intermediate data structures and greatly reduce the

   806      * number of iteratee executions.

   807      *

   808      * Chaining is supported in custom builds as long as the `_#value` method is

   809      * directly or indirectly included in the build.

   810      *

   811      * In addition to lodash methods, wrappers have `Array` and `String` methods.

   812      *

   813      * The wrapper `Array` methods are:

   814      * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`,

   815      * `splice`, and `unshift`

   816      *

   817      * The wrapper `String` methods are:

   818      * `replace` and `split`

   819      *

   820      * The wrapper methods that support shortcut fusion are:

   821      * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,

   822      * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,

   823      * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,

   824      * and `where`

   825      *

   826      * The chainable wrapper methods are:

   827      * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,

   828      * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,

   829      * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defaultsDeep`,

   830      * `defer`, `delay`, `difference`, `drop`, `dropRight`, `dropRightWhile`,

   831      * `dropWhile`, `fill`, `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`,

   539      * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,

   834      * `invoke`, `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`,

   540      * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`,

   835      * `matchesProperty`, `memoize`, `merge`, `method`, `methodOf`, `mixin`,

   541      * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`,

   836      * `modArgs`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`,

   542      * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`,

   837      * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,

   543      * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`,

   838      * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `restParam`,

   544      * and `zip`

   839      * `reverse`, `set`, `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`,

   545      *

   840      * `sortByOrder`, `splice`, `spread`, `take`, `takeRight`, `takeRightWhile`,

   546      * The non-chainable wrapper functions are:

   841      * `takeWhile`, `tap`, `throttle`, `thru`, `times`, `toArray`, `toPlainObject`,

   547      * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`,

   842      * `transform`, `union`, `uniq`, `unshift`, `unzip`, `unzipWith`, `values`,

   548      * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`,

   843      * `valuesIn`, `where`, `without`, `wrap`, `xor`, `zip`, `zipObject`, `zipWith`

   549      * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,

   844      *

   550      * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`,

   845      * The wrapper methods that are **not** chainable by default are:

   551      * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`,

   846      * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clone`, `cloneDeep`,

   552      * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`,

   847      * `deburr`, `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`,

   553      * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`,

   848      * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`,

   554      * `template`, `unescape`, `uniqueId`, and `value`

   849      * `floor`, `get`, `gt`, `gte`, `has`, `identity`, `includes`, `indexOf`,

   555      *

   850      * `inRange`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,

   556      * The wrapper functions `first` and `last` return wrapped values when `n` is

   851      * `isEmpty`, `isEqual`, `isError`, `isFinite` `isFunction`, `isMatch`,

   557      * provided, otherwise they return unwrapped values.

   852      * `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`,

   558      *

   853      * `isRegExp`, `isString`, `isUndefined`, `isTypedArray`, `join`, `kebabCase`,

   559      * Explicit chaining can be enabled by using the `_.chain` method.

   854      * `last`, `lastIndexOf`, `lt`, `lte`, `max`, `min`, `noConflict`, `noop`,

   855      * `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`, `reduce`,

   856      * `reduceRight`, `repeat`, `result`, `round`, `runInContext`, `shift`, `size`,

   857      * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`,

   858      * `startsWith`, `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`,

   859      * `unescape`, `uniqueId`, `value`, and `words`

   860      *

   861      * The wrapper method `sample` will return a wrapped value when `n` is provided,

   862      * otherwise an unwrapped value is returned.

   563      * @category Chaining

   866      * @category Chain

   565      * @returns {Object} Returns a `lodash` instance.

   868      * @returns {Object} Returns the new `lodash` wrapper instance.

   571      * wrapped.reduce(function(sum, num) {

   874      * wrapped.reduce(function(total, n) {

   572      *   return sum + num;

   875      *   return total + n;

   577      * var squares = wrapped.map(function(num) {

   880      * var squares = wrapped.map(function(n) {

   578      *   return num * num;

   881      *   return n * n;

   588       // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor

   891       if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {

   589       return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))

   892         if (value instanceof LodashWrapper) {

   590        ? value

   893           return value;

   591        : new lodashWrapper(value);

   894         }

   592     }

   895         if (hasOwnProperty.call(value, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) {

   593 

   896           return wrapperClone(value);

   594     /**

   897         }

   595      * A fast path for creating `lodash` wrapper objects.

   898       }

   596      *

   899       return new LodashWrapper(value);

   597      * @private

   900     }

   598      * @param {*} value The value to wrap in a `lodash` instance.

   901 

   599      * @param {boolean} chainAll A flag to enable chaining for all methods

   902     /**

   600      * @returns {Object} Returns a `lodash` instance.

   903      * The function whose prototype all chaining wrappers inherit from.

   601      */

   904      *

   602     function lodashWrapper(value, chainAll) {

   905      * @private

   906      */

   907     function baseLodash() {

   908       // No operation performed.

   909     }

   910 

   911     /**

   912      * The base constructor for creating `lodash` wrapper objects.

   913      *

   914      * @private

   915      * @param {*} value The value to wrap.

   916      * @param {boolean} [chainAll] Enable chaining for all wrapper methods.

   917      * @param {Array} [actions=[]] Actions to peform to resolve the unwrapped value.

   918      */

   919     function LodashWrapper(value, chainAll, actions) {

   920       this.__wrapped__ = value;

   921       this.__actions__ = actions || [];

   604       this.__wrapped__ = value;

   923     }

   605     }

   924 

   606     // ensure `new lodashWrapper` is an instance of `lodash`

   925     /**

   607     lodashWrapper.prototype = lodash.prototype;

   926      * An object environment feature flags.

   608 

   609     /**

   610      * An object used to flag environments features.

   619      * Detect if functions can be decompiled by `Function#toString`

   935      * By default, the template delimiters used by lodash are like those in

   620      * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).

   936      * embedded Ruby (ERB). Change the following template settings to use

   621      *

   937      * alternative delimiters.

   622      * @memberOf _.support

   623      * @type boolean

   624      */

   625     support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext);

   626 

   627     /**

   628      * Detect if `Function#name` is supported (all but IE).

   629      *

   630      * @memberOf _.support

   631      * @type boolean

   632      */

   633     support.funcNames = typeof Function.name == 'string';

   634 

   635     /**

   636      * By default, the template delimiters used by Lo-Dash are similar to those in

   637      * embedded Ruby (ERB). Change the following template settings to use alternative

   638      * delimiters.

   652       'escape': /<%-([\s\S]+?)%>/g,

   951       'escape': reEscape,

   660       'evaluate': /<%([\s\S]+?)%>/g,

   959       'evaluate': reEvaluate,

   696     /*--------------------------------------------------------------------------*/

   995     /*------------------------------------------------------------------------*/

   697 

   996 

   698     /**

   997     /**

   699      * The base implementation of `_.bind` that creates the bound function and

   998      * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.

   700      * sets its meta data.

   999      *

   701      *

  1000      * @private

   702      * @private

  1001      * @param {*} value The value to wrap.

   703      * @param {Array} bindData The bind data array.

  1002      */

   704      * @returns {Function} Returns the new bound function.

  1003     function LazyWrapper(value) {

   705      */

  1004       this.__wrapped__ = value;

   706     function baseBind(bindData) {

  1005       this.__actions__ = [];

   707       var func = bindData[0],

  1006       this.__dir__ = 1;

   708           partialArgs = bindData[2],

  1007       this.__filtered__ = false;

   709           thisArg = bindData[4];

  1008       this.__iteratees__ = [];

   710 

  1009       this.__takeCount__ = POSITIVE_INFINITY;

   711       function bound() {

  1010       this.__views__ = [];

   712         // `Function#bind` spec

  1011     }

   713         // http://es5.github.io/#x15.3.4.5

  1012 

   714         if (partialArgs) {

  1013     /**

   715           // avoid `arguments` object deoptimizations by using `slice` instead

  1014      * Creates a clone of the lazy wrapper object.

   716           // of `Array.prototype.slice.call` and not assigning `arguments` to a

  1015      *