Lines Matching refs:_
345 var _ = root._ || (root._ = interopRequire(filePath)); variable
349 var MapCache = (_.memoize || lodashStable.memoize).Cache;
354 (_.isMatchWith || lodashStable.isMatchWith)({ 'a': 1 }, { 'a': 1 }, function() {
378 var oldDash = root._;
588 root._ = oldDash;
673 _._realm = realm;
726 delete _._realm;
733 _._VERSION = e.data || '';
751 _['_' + funcName] = interopRequire(path.join(basePath, '_' + funcName));
808 var actual = _._VERSION;
813 assert.strictEqual(actual, _.VERSION);
933 var func = _._isIndex;
978 func = _._isIterateeCall,
1121 return _(value) instanceof _;
1136 var wrapped = _(value);
1137 return _(wrapped) === wrapped;
1152 var wrapped = _(lodashBizarro(value)),
1155 return wrapped instanceof _ &&
1175 assert.strictEqual(_.add(6, 4), 10);
1176 assert.strictEqual(_.add(-6, 4), -2);
1177 assert.strictEqual(_.add(-6, -4), -10);
1183 assert.strictEqual(_.add('6', '4'), '64');
1184 assert.strictEqual(_.add('x', 'y'), 'xy');
1195 lodashStable.times(times, _.after(n, function() { count++; }));
1217 var after = _.after(1, function(assert) { return ++this.count; }),
1238 var actual = lodashStable.map(['6', '8', '10'], _.ary(parseInt, 1));
1241 var capped = _.ary(fn, 2);
1248 var capped = _.ary(fn);
1255 var capped = _.ary(fn, -1);
1271 var capped = _.ary(fn, n);
1282 capped = _.ary(fn, 3);
1298 var capped = _.ary(function(a, b) { return this; }, 1),
1307 var capped = _.ary(_.ary(fn, 1), 2);
1314 var funcs = lodashStable.map([fn], _.ary),
1324 includes = _.curry(_.rearg(_.ary(_.includes, 2), 1, 0), 2);
1329 includes = _(_.includes).ary(2).rearg(1, 0).curry(2).value();
1346 assert.strictEqual(_.extend, _.assignIn);
1355 var func = _[methodName];
1461 assert.strictEqual(_.extendWith, _.assignInWith);
1470 var func = _[methodName];
1501 var actual = _.at(array, [0, 2]);
1508 var actual = _.at(array, [2, 4, 0]);
1524 actual = _.at(array, values);
1532 assert.deepEqual(_.at(array), []);
1533 assert.deepEqual(_.at(array, [], []), []);
1539 var actual = _.at(['a', 'b', 'c', 'd'], 3, 0, 2);
1550 return _.at(object, 0, 1, 'pop', 'push');
1560 var actual = _.at(args, [2, 0]);
1567 var actual = _.at([1, 2, 3, 4, 5], args);
1574 var actual = _.at(object, ['a[0].b.c', 'a[1]']);
1586 var actual = _.at(new Foo, 'b');
1600 wrapped = _(array).map(identity).at(paths);
1602 assert.deepEqual(wrapped.value(), _.at(_.map(array, identity), paths));
1622 var actual = _(array).map(iteratee).at(n).value(),
1641 actual = _(object).map(identity).at(paths).value();
1643 assert.deepEqual(actual, _.at(_.map(object, identity), paths));
1646 actual = _(indexObject).at(0).value();
1647 assert.deepEqual(actual, _.at(indexObject, 0));
1663 assert.strictEqual(_.attempt(lodashStable.constant('x')), 'x');
1669 var actual = _.attempt(function() { return slice.call(arguments); }, 1, 2);
1679 return _.attempt(function() { throw error; }) === error;
1688 var actual = _.attempt(function() { throw 'x'; });
1695 var actual = _.attempt(function() { throw new CustomError('x'); });
1706 return _.attempt(function() { throw error; }) === error;
1720 assert.strictEqual(_(lodashStable.constant('x')).attempt(), 'x');
1731 assert.ok(_(lodashStable.constant('x')).chain().attempt() instanceof _);
1746 lodashStable.times(times, _.before(n, function() { count++; }));
1768 var before = _.before(2, function(assert) { return ++this.count; }),
1792 bound = _.bind(fn, object);
1805 var bound = _.bind(fn, value);
1818 var bound = _.bind(fn, null),
1825 bound = index ? _.bind(fn, undefined) : _.bind(fn);
1837 bound = _.bind(fn, object, 'a');
1841 bound = _.bind(fn, object, 'a');
1844 bound = _.bind(fn, object, 'a', 'b');
1853 ph = _.bind.placeholder,
1854 bound = _.bind(fn, object, ph, 'b', ph);
1866 var _ph = _.placeholder = {},
1867 ph = _.bind.placeholder,
1869 bound = _.bind(fn, object, _ph, 'b', ph);
1872 delete _.placeholder;
1883 bound = _.bind(fn, {});
1887 bound = _.bind(fn, {}, 1);
1898 var bound = _.bind(Foo, { 'a': 1 }),
1916 boundFoo = _.bind(Foo, thisArg),
1917 boundBar = _.bind(Bar, thisArg),
1947 var bound = _.bind(Foo),
1958 bound = _.bind(fn, object, 'a');
1970 var bound1 = _.bind(fn, object1),
1971 bound2 = _.bind(bound1, object2, 'a'),
1972 bound3 = _.bind(bound1, object3, 'b');
1982 var Ctor = _.bind(Date, null),
1991 Ctor = _.bind(Date, null, 2012, 4, 23);
2006 var bound = _.bind(createCtor()),
2037 bound = _(fn).bind({}, 'a', 'b');
2039 assert.ok(bound instanceof _);
2076 _.bindAll(object, 'a', 'b');
2089 _.bindAll(object, ['a', 'b'], ['c']);
2105 _.bindAll(object, key);
2116 _.bindAll(array);
2124 _.bindAll(object, args);
2149 var bound = _.bindKey(object, 'greet', 'hi');
2168 var ph = _.bindKey.placeholder,
2169 bound = _.bindKey(object, 'fn', ph, 'b', ph);
2187 var _ph = _.placeholder = {},
2188 ph = _.bindKey.placeholder,
2189 bound = _.bindKey(object, 'fn', _ph, 'b', ph);
2192 delete _.placeholder;
2207 bound = _.bindKey(object, 'Foo');
2220 func = _[methodName];
2322 assert.strictEqual(_('foo bar')[methodName](), converted);
2333 assert.ok(_('foo bar').chain()[methodName]() instanceof _);
2345 …var funcs = [_.camelCase, _.kebabCase, _.lowerCase, _.snakeCase, _.startCase, _.lowerCase, _.camel…
2363 assert.strictEqual(_.camelCase('12 feet'), '12Feet');
2364 assert.strictEqual(_.camelCase('enable 6h format'), 'enable6HFormat');
2365 assert.strictEqual(_.camelCase('enable 24H format'), 'enable24HFormat');
2366 assert.strictEqual(_.camelCase('too legit 2 quit'), 'tooLegit2Quit');
2367 assert.strictEqual(_.camelCase('walk 500 miles'), 'walk500Miles');
2368 assert.strictEqual(_.camelCase('xhr2 request'), 'xhr2Request');
2375 assert.strictEqual(_.camelCase(string), 'safeHtml');
2379 assert.strictEqual(_.camelCase(string), 'escapeHtmlEntities');
2383 assert.strictEqual(_.camelCase(string), 'xmlHttpRequest');
2396 assert.strictEqual(_.capitalize('fred'), 'Fred');
2397 assert.strictEqual(_.capitalize('Fred'), 'Fred');
2398 assert.strictEqual(_.capitalize(' fred'), ' fred');
2412 actual = lodashStable.map(values, _.castArray);
2421 assert.strictEqual(_.castArray(array), array);
2427 assert.deepEqual(_.castArray(), []);
2440 var actual = _.chain({ 'a': 0 });
2441 assert.ok(actual instanceof _);
2452 var wrapped = _({ 'a': 0 });
2453 assert.strictEqual(_.chain(wrapped), wrapped);
2467 assert.ok(_.chain(array).head() instanceof _);
2468 assert.ok(_(array).chain().head() instanceof _);
2470 assert.ok(_.chain(array).isArray() instanceof _);
2471 assert.ok(_(array).chain().isArray() instanceof _);
2473 assert.ok(_.chain(array).sortBy().head() instanceof _);
2474 assert.ok(_(array).chain().sortBy().head() instanceof _);
2488 wrapped = index ? _(array).chain() : _.chain(array);
2504 wrapped = index ? _(array).chain() : _.chain(array);
2515 wrapped = index ? _(array).chain() : _.chain(array);
2543 var actual = _.chunk(array, 3);
2550 var actual = _.chunk(array, 4);
2562 return index ? _.chunk(array, size) : _.chunk(array);
2575 return _.chunk(array, n);
2584 assert.deepEqual(_.chunk(array, array.length / 4), [[0], [1], [2], [3], [4], [5]]);
2590 var actual = lodashStable.map([[1, 2], [3, 4]], _.chunk);
2603 assert.strictEqual(_.clamp(5, 3), 3);
2604 assert.strictEqual(_.clamp(1, 3), 1);
2610 assert.strictEqual(_.clamp(-10, -5, 5), -5);
2611 assert.strictEqual(_.clamp(-10.2, -5.5, 5.5), -5.5);
2612 assert.strictEqual(_.clamp(-Infinity, -5, 5), -5);
2618 assert.strictEqual(_.clamp(10, -5, 5), 5);
2619 assert.strictEqual(_.clamp(10.6, -5.6, 5.4), 5.4);
2620 assert.strictEqual(_.clamp(Infinity, -5, 5), 5);
2626 assert.strictEqual(_.clamp(-4, -5, 5), -4);
2627 assert.strictEqual(_.clamp(-5, -5, 5), -5);
2628 assert.strictEqual(_.clamp(-5.5, -5.6, 5.6), -5.5);
2634 assert.strictEqual(_.clamp(4, -5, 5), 4);
2635 assert.strictEqual(_.clamp(5, -5, 5), 5);
2636 assert.strictEqual(_.clamp(4.5, -5.1, 5.2), 4.5);
2642 assert.strictEqual(1 / _.clamp(0, -5, 5), Infinity);
2648 assert.strictEqual(1 / _.clamp(-10, 0, 5), Infinity);
2654 assert.strictEqual(1 / _.clamp(-0, -5, 5), -Infinity);
2660 assert.strictEqual(1 / _.clamp(-10, -0, 5), -Infinity);
2666 assert.deepEqual(_.clamp(NaN, -5, 5), NaN);
2672 assert.deepEqual(_.clamp(1, -5, NaN), 0);
2673 assert.deepEqual(_.clamp(-1, NaN, 5), 0);
2738 actual = _.clone(array);
2755 var actual = _.cloneDeep(object);
2767 var clone = _.cloneDeep(cyclical),
2779 _.cloneDeepWith({ 'a': 1 }, function() {
2780 actual = _.last(arguments);
2790 var func = _[methodName],
3019 var objects = lodashStable.transform(_, function(result, value, key) {
3060 actual = _(object)[methodName]();
3116 var func = _[methodName],
3174 assert.deepEqual(_.compact(falsey.concat(array)), array);
3181 var actual = _(falsey).thru(_.slice).compact().thru(_.slice).value();
3184 actual = _(falsey).thru(_.slice).push(true, 1).compact().push('a').value();
3196 var actual = _(largeArray).slice(1).compact().reverse().take().value();
3197 assert.deepEqual(actual, _.take(_.compact(_.slice(largeArray, 1)).reverse()));
3208 var iteratee = _.iteratee,
3211 _.iteratee = identity;
3214 var actual = _(largeArray).slice(1).compact().value();
3215 pass = lodashStable.isEqual(actual, _.compact(_.slice(largeArray, 1)));
3219 _.iteratee = iteratee;
3236 actual = _.concat(array);
3246 actual = _.concat(array, 2, [3], [[4]]);
3262 return index ? _.concat(value) : _.concat();
3272 return _.concat(value, [2], [[3]]);
3282 actual = _.concat(Array(1), Array(1));
3296 wrapped = _(array).concat([2, 3]),
3316 var cond = _.cond([
3334 var cond = _.cond([[
3348 var cond = _.cond([
3362 var cond = _.cond([[stubFalse, stubA]]);
3370 assert.raises(function() { _.cond([[stubTrue, value]])(); }, TypeError);
3377 var cond = _.cond([
3396 par = _.conforms(source);
3413 return isConforms ? _.conforms(source) : function(object) {
3414 return _.conformsTo(object, source);
3584 constant = _.constant(object);
3604 var constant = index ? _.constant(value) : _.constant(),
3617 var wrapped = _(true).constant();
3618 assert.ok(wrapped instanceof _);
3636 var actual = _.countBy(array, Math.floor);
3648 return index ? _.countBy(array, value) : _.countBy(array);
3657 var actual = _.countBy(['one', 'two', 'three'], 'length');
3664 var actual = _.countBy(array, function(n) {
3681 assert.deepEqual(_.countBy(array, 0), { '1': 1, '2': 2 });
3682 assert.deepEqual(_.countBy(array, 1), { 'a': 2, 'b': 1 });
3688 var actual = _.countBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
3701 var actual = _(array).countBy().map(square).filter(isEven).take().value();
3703 assert.deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), isEven)));
3728 Circle.prototype = _.create(Shape.prototype);
3742 Circle.prototype = _.create(Shape.prototype, expected);
3760 assert.deepEqual(_.create({}, new Foo), { 'a': 1, 'c': 3 });
3769 var object = _.create(new Foo, { 'a': 1 });
3779 return index ? _.create(prototype) : _.create();
3791 return lodashStable.isPlainObject(index ? _.create(value) : _.create());
3802 objects = lodashStable.map(array, _.create);
3805 return object.a === 1 && !_.keys(object).length;
3824 var curried = _.curry(fn),
3835 var curried = _.curry(fn, 3),
3850 return _.curry(fn, arity)();
3854 assert.deepEqual(_.curry(fn, '2')(1)(2), [1, 2]);
3860 var curried = _.curry(fn),
3872 var curried = _.curry(fn),
3883 var curried = _.curry(fn),
3884 _ph = _.placeholder = {},
3888 delete _.placeholder;
3898 var curried = _.curry(fn, 3);
3908 var curried = index ? _.curry(fn, 4) : _.curry(fn);
3922 var curried = _.curry(Foo),
3940 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a')('b')('c'), expected);
3941 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b')('c'), expected);
3942 assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
3944 assert.deepEqual(_.bind(_.curry(fn), object)('a')('b')('c'), Array(3));
3945 assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b')('c'), Array(3));
3946 assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b', 'c'), expected);
3948 object.curried = _.curry(fn);
3957 var curried = _.curry(fn),
3960 var a = _.partial(curried, 1),
3961 b = _.bind(a, null, 2),
3962 c = _.partialRight(b, 4),
3963 d = _.partialRight(b(3), 4);
3982 var curried = _.curryRight(fn),
3993 var curried = _.curryRight(fn, 3),
4008 return _.curryRight(fn, arity)();
4012 assert.deepEqual(_.curryRight(fn, '2')(1)(2), [2, 1]);
4018 var curried = _.curryRight(fn),
4031 var curried = _.curryRight(fn),
4042 var curried = _.curryRight(fn),
4043 _ph = _.placeholder = {},
4047 delete _.placeholder;
4057 var curried = _.curryRight(fn, 3);
4067 var curried = index ? _.curryRight(fn, 4) : _.curryRight(fn);
4081 var curried = _.curryRight(Foo),
4099 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('c')('b')('a'), expected);
4100 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('b', 'c')('a'), expected);
4101 assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('a', 'b', 'c'), expected);
4103 assert.deepEqual(_.bind(_.curryRight(fn), object)('c')('b')('a'), Array(3));
4104 assert.deepEqual(_.bind(_.curryRight(fn), object)('b', 'c')('a'), Array(3));
4105 assert.deepEqual(_.bind(_.curryRight(fn), object)('a', 'b', 'c'), expected);
4107 object.curried = _.curryRight(fn);
4116 var curried = _.curryRight(fn),
4119 var a = _.partialRight(curried, 4),
4120 b = _.partialRight(a, 3),
4121 c = _.bind(b, null, 1),
4122 d = _.partial(b(2), 1);
4134 var func = _[methodName],
4157 var curried = _.curry(function hasOwnProperty(a, b, c) {
4197 var debounced = _.debounce(function(value) {
4225 var debounced = _.debounce(identity, 32);
4244 debounced = _.debounce(function() { ++callCount; }, 0);
4262 debounced = _.debounce(function() { callCount++; }, 32, {});
4280 var withLeading = _.debounce(function() {
4284 var withLeadingAndTrailing = _.debounce(function() {
4310 var debounced = _.debounce(identity, 32, { 'leading': true, 'trailing': false }),
4330 var withTrailing = _.debounce(function() {
4334 var withoutTrailing = _.debounce(function() {
4358 var debounced = _.debounce(function(value) {
4389 var withMaxWait = _.debounce(function() {
4393 var withoutMaxWait = _.debounce(function() {
4416 var debounced = _.debounce(function() {
4439 var debounced = _.debounce(function() {
4465 var debounced = _.debounce(function(value) {
4492 var actual = lodashStable.map(burredLetters, _.deburr);
4500 actual = lodashStable.map(operators, _.deburr);
4511 return _.deburr('e' + chr + 'i');
4526 var actual = _.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 });
4534 actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 });
4538 actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 });
4545 var actual = _.defaults({ 'a': null }, { 'a': 1 });
4552 var actual = _.defaults({ 'a': undefined }, { 'a': 1 });
4560 actual = _.defaults({}, source);
4589 assert.deepEqual(_.defaults({}, source), expected);
4592 assert.deepEqual(_.defaults({}, object, source), expected);
4608 assert.deepEqual(_.defaultsDeep(object, source), expected);
4620 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source1, source2), expected);
4621 assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source3, source4), expected);
4629 actual = _.defaultsDeep(object, source);
4639 actual = _.defaultsDeep(object, source);
4647 var actual = _.defaultsDeep({}, { 'a': noop });
4650 actual = _.defaultsDeep({}, { 'a': { 'b': noop } });
4659 actual = _.defaultsDeep(object, source);
4669 actual = _.defaultsDeep({}, source);
4691 var actual = _.defaultsDeep(object, source);
4702 actual = _.defaultsDeep({}, source1, source2);
4712 var actual = _.defaultsDeep({ 'a': ['abc'] }, { 'a': 'abc' });
4719 _.defaultsDeep({}, { 'constructor': { 'a': 1 } });
4741 return _.defaultTo(value, 1);
4759 _.defer(function() { pass = true; });
4774 _.defer(function() {
4790 timerId = _.defer(function() { pass = false; });
4812 _.delay(function() { pass = true; }, 32);
4831 _.delay(function() {
4847 _.delay(function() { pass = true; });
4863 timerId = _.delay(function() { pass = false; }, 32);
4881 _.delay(function() { pass = true; }, 32);
4897 var func = _[methodName];
5002 var actual = _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
5005 actual = _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
5014 _.differenceBy([2.1, 1.2], [2.3, 3.4], function() {
5031 actual = _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], lodashStable.isEqual);
5045 … return lodashStable.map(_.differenceWith(array, other, lodashStable.eq), lodashStable.toString);
5060 assert.strictEqual(_.divide(6, 4), 1.5);
5061 assert.strictEqual(_.divide(-6, 4), -1.5);
5062 assert.strictEqual(_.divide(-6, -4), 1.5);
5068 assert.strictEqual(_.divide('6', '4'), 1.5);
5069 assert.deepEqual(_.divide('x', 'y'), NaN);
5083 assert.deepEqual(_.drop(array, 2), [3]);
5094 return _.drop(array, n);
5104 assert.deepEqual(_.drop(array, n), array);
5112 assert.deepEqual(_.drop(array, n), []);
5119 assert.deepEqual(_.drop(array, 1.6), [2, 3]);
5126 actual = lodashStable.map(array, _.drop);
5138 actual = _(array).drop(2).drop().value();
5142 actual = _(array).filter(predicate).drop(2).drop().value();
5144 assert.deepEqual(actual, _.drop(_.drop(_.filter(array, predicate), 2)));
5146 actual = _(array).drop(2).dropRight().drop().dropRight(2).value();
5147 assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(array, 2))), 2));
5151 actual = _(array).drop().filter(predicate).drop(2).dropRight().drop().dropRight(2).value();
5153 …assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(_.filter(_.drop(array), predicate),…
5171 assert.deepEqual(_.dropRight(array, 2), [1]);
5182 return _.dropRight(array, n);
5192 assert.deepEqual(_.dropRight(array, n), array);
5200 assert.deepEqual(_.dropRight(array, n), []);
5207 assert.deepEqual(_.dropRight(array, 1.6), [1, 2]);
5214 actual = lodashStable.map(array, _.dropRight);
5226 actual = _(array).dropRight(2).dropRight().value();
5230 actual = _(array).filter(predicate).dropRight(2).dropRight().value();
5232 assert.deepEqual(actual, _.dropRight(_.dropRight(_.filter(array, predicate), 2)));
5234 actual = _(array).dropRight(2).drop().dropRight().drop(2).value();
5235 assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(array, 2))), 2));
5239 … actual = _(array).dropRight().filter(predicate).dropRight(2).drop().dropRight().drop(2).value();
5241 …assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(_.filter(_.dropRight(array), predic…
5265 var actual = _.dropRightWhile(array, function(n) {
5277 _.dropRightWhile(array, function() {
5287 assert.deepEqual(_.dropRightWhile(objects, { 'b': 2 }), objects.slice(0, 2));
5293 assert.deepEqual(_.dropRightWhile(objects, ['b', 2]), objects.slice(0, 2));
5299 assert.deepEqual(_.dropRightWhile(objects, 'b'), objects.slice(0, 1));
5306 var wrapped = _(array).dropRightWhile(function(n) {
5310 assert.ok(wrapped instanceof _);
5335 var actual = _.dropWhile(array, function(n) {
5347 _.dropWhile(array, function() {
5357 assert.deepEqual(_.dropWhile(objects, { 'b': 2 }), objects.slice(1));
5363 assert.deepEqual(_.dropWhile(objects, ['b', 2]), objects.slice(1));
5369 assert.deepEqual(_.dropWhile(objects, 'b'), objects.slice(2));
5378 expected = _.dropWhile(array, predicate),
5379 wrapped = _(array).dropWhile(predicate);
5383 assert.strictEqual(wrapped.last(), _.last(expected));
5396 var actual = _(array)
5420 assert.strictEqual(_.endsWith(string, 'c'), true);
5426 assert.strictEqual(_.endsWith(string, 'b'), false);
5432 assert.strictEqual(_.endsWith(string, 'b', 2), true);
5439 assert.strictEqual(_.endsWith(string, 'c', position), true);
5449 return _.endsWith(string, position === undefined ? 'c' : '', position);
5460 return !_.endsWith(string, chr, position);
5462 assert.strictEqual(_.endsWith(string, '', position), true);
5469 assert.strictEqual(_.endsWith(string, 'ab', 2.2), true);
5481 assert.strictEqual(_.eq(), true);
5482 assert.strictEqual(_.eq(undefined), true);
5483 assert.strictEqual(_.eq(0, -0), true);
5484 assert.strictEqual(_.eq(NaN, NaN), true);
5485 assert.strictEqual(_.eq(1, 1), true);
5487 assert.strictEqual(_.eq(null, undefined), false);
5488 assert.strictEqual(_.eq(1, Object(1)), false);
5489 assert.strictEqual(_.eq(1, '1'), false);
5490 assert.strictEqual(_.eq(1, '1'), false);
5493 assert.strictEqual(_.eq(object, object), true);
5494 assert.strictEqual(_.eq(object, { 'a': 1 }), false);
5512 assert.strictEqual(_.escape(unescaped), escaped);
5518 assert.strictEqual(_.escape('abc'), 'abc');
5524 assert.strictEqual(_.escape(_.unescape(escaped)), escaped);
5531 assert.strictEqual(_.escape(chr), chr);
5547 assert.strictEqual(_.escapeRegExp(unescaped + unescaped), escaped + escaped);
5553 assert.strictEqual(_.escapeRegExp('abc'), 'abc');
5563 return index ? _.escapeRegExp(value) : _.escapeRegExp();
5588 return _.every(value, identity);
5600 assert.strictEqual(_.every([true, null, true], function(value) {
5611 assert.strictEqual(_.every([undefined, undefined, undefined], identity), false);
5622 return index ? _.every(array, value) : _.every(array);
5630 return index ? _.every(array, value) : _.every(array);
5640 assert.strictEqual(_.every(objects, 'a'), false);
5641 assert.strictEqual(_.every(objects, 'b'), true);
5648 assert.strictEqual(_.every(objects, { 'a': 0 }), true);
5649 assert.strictEqual(_.every(objects, { 'b': 1 }), false);
5655 var actual = lodashStable.map([[1]], _.every);
5665 var func = _[methodName],
5692 assert.deepEqual(_.fill(array, 'a'), ['a', 'a', 'a']);
5699 actual = _.fill(array);
5711 assert.deepEqual(_.fill(array, 'a', 1), [1, 'a', 'a']);
5719 assert.deepEqual(_.fill(array, 'a', start), [1, 2, 3]);
5730 return _.fill(array, 'a', start);
5740 assert.deepEqual(_.fill(array, 'a', -1), [1, 2, 'a']);
5748 assert.deepEqual(_.fill(array, 'a', start), ['a', 'a', 'a']);
5757 assert.deepEqual(_.fill(array, 'a', start, 2), [1, 2, 3]);
5765 assert.deepEqual(_.fill(array, 'a', 0, 1), ['a', 2, 3]);
5773 assert.deepEqual(_.fill(array, 'a', 0, end), ['a', 'a', 'a']);
5786 return _.fill(array, 'a', 0, end);
5796 assert.deepEqual(_.fill(array, 'a', 0, -1), ['a', 'a', 3]);
5804 assert.deepEqual(_.fill(array, 'a', 0, end), [1, 2, 3]);
5815 return _.fill.apply(_, [array, 'a'].concat(pos));
5825 actual = lodashStable.map(array, _.fill);
5835 wrapped = _(array).fill('a'),
5838 assert.ok(wrapped instanceof _);
5858 assert.deepEqual(_.filter(array, isEven), [2]);
5868 func = _[methodName];
5943 assert.strictEqual(_(array)[methodName](), expected);
5954 assert.ok(_(array).chain()[methodName]() instanceof _);
5965 var wrapped = _(array).chain()[methodName]();
5982 wrapped = _(array).filter(isEven);
5993 _.each(['find', 'findIndex', 'findLast', 'findLastIndex'], function(methodName) {
5994 var func = _[methodName];
6010 _.each(['find', 'findKey', 'findLast', 'findLastKey'], function(methodName) {
6011 var func = _[methodName];
6060 actual = _(array).map(iteratee)[methodName](predicate);
6077 var func = _[methodName],
6192 func = _[methodName],
6285 _.findLast(collection, resolve(values[1]), 1),
6286 _.findLast(collection, resolve(values[2]), 1)
6301 _.findLast(collection, resolve(1), fromIndex),
6302 _.findLast(collection, resolve(undefined), fromIndex),
6303 _.findLast(collection, resolve(''), fromIndex)
6318 return _.findLast(collection, resolve(values[3]), fromIndex);
6334 _.findLast(collection, resolve(values[0]), 0.1),
6335 _.findLast(collection, resolve(values[0]), NaN),
6336 _.findLast(collection, resolve(values[2]), '1')
6351 _.findLast(collection, resolve(values[1]), -2),
6352 _.findLast(collection, resolve(values[2]), -2)
6365 return _.findLast(collection, resolve(values[0]), fromIndex);
6385 var flipped = _.flip(fn);
6400 assert.deepEqual(_.flatMapDepth(array, identity), [1, 2, [3, [4]], 5]);
6410 return index ? _.flatMapDepth(array, value) : _.flatMapDepth(array);
6420 assert.deepEqual(_.flatMapDepth(array, identity, depth), [1, [2, [3, [4]], 5]]);
6427 assert.deepEqual(_.flatMapDepth(array, identity, 2.2), [1, 2, 3, [4], 5]);
6436 var func = _[methodName],
6526 assert.deepEqual(_.flattenDepth(array), [1, 2, [3, [4]], 5]);
6533 assert.deepEqual(_.flattenDepth(array, depth), [1, [2, [3, [4]], 5]]);
6540 assert.deepEqual(_.flattenDepth(array, 2.2), [1, 2, 3, [4], 5]);
6557 assert.deepEqual(_.flatten(array), [1, 2, 3, args]);
6558 assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 1, 2, 3]);
6559 assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, 1, 2, 3]);
6571 var actual = _[methodName](array);
6588 return _[methodName](array);
6604 var func = _.flatten;
6606 func = _.flattenDeep;
6608 func = _.flattenDepth;
6622 assert.deepEqual(_.flatten(array), [[], [], [[[]]]]);
6623 assert.deepEqual(_.flattenDeep(array), []);
6624 assert.deepEqual(_.flattenDepth(array, 2), [[[]]]);
6630 assert.deepEqual(_.flatten(array), [1, 2, [3, [4]], 5]);
6631 assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 4, 5]);
6632 assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, [4], 5]);
6641 assert.deepEqual(_.flatten(nonArray), expected);
6642 assert.deepEqual(_.flattenDeep(nonArray), expected);
6643 assert.deepEqual(_.flattenDepth(nonArray, 2), expected);
6650 var wrapped = _(array),
6653 assert.ok(actual instanceof _);
6658 assert.ok(actual instanceof _);
6663 assert.ok(actual instanceof _);
6677 var func = _[methodName],
6698 _.times(2, function(index) {
6713 var curried = _.curry(identity);
6716 ? func(_.head, curried)
6717 : func(curried, _.head);
6732 var filter1 = _.filter,
6733 filter2 = _.curry(_.rearg(_.ary(_.filter, 2), 1, 0), 2),
6734 filter3 = (_.filter = index ? filter2 : filter1, filter2(predicate));
6736 var map1 = _.map,
6737 map2 = _.curry(_.rearg(_.ary(_.map, 2), 1, 0), 2),
6738 map3 = (_.map = index ? map2 : map1, map2(iteratee));
6740 var take1 = _.take,
6741 take2 = _.curry(_.rearg(_.ary(_.take, 2), 1, 0), 2),
6742 take3 = (_.take = index ? take2 : take1, take2(2));
6745 ? func(map3, filter3, _.compact, take3)
6746 : func(take3, _.compact, filter3, map3);
6758 _.filter = filter1;
6759 _.map = map1;
6760 _.take = take1;
6767 var curried = _.curry(_.ary(_.map, 2), 2),
6772 ? func(getProp, _.uniq)
6773 : func(_.uniq, getProp);
6782 var wrapped = _(noop)[methodName]();
6783 assert.ok(wrapped instanceof _);
6799 assert.strictEqual(_.each, _.forEach);
6811 assert.strictEqual(_.eachRight, _.forEachRight);
6820 var func = _[methodName];
6841 var func = _[methodName];
6980 func = _[methodName],
7055 func = _[methodName],
7086 var wrapped = _(array)[methodName](noop);
7087 assert.ok(wrapped instanceof _);
7102 var actual = _(array)[methodName](noop);
7103 assert.notOk(actual instanceof _);
7114 var wrapped = _(array).chain(),
7117 assert.ok(actual instanceof _);
7127 var func = _[methodName];
7150 func = _[methodName];
7165 var func = _[methodName];
7198 var func = _[methodName],
7226 var func = _[methodName],
7259 var func = _[methodName],
7350 var wrapped = _({ 'a': 1 }),
7362 var func = _[methodName];
7371 assert.notOk(_.has(actual, 'a'));
7376 var func = _[methodName];
7399 var func = _[methodName],
7464 var func = _[methodName];
7521 assert.deepEqual(_.difference(largeArray, largeArray), []);
7522 assert.deepEqual(_.intersection(largeArray, largeArray), expected);
7523 assert.deepEqual(_.uniq(largeArray), expected);
7524 assert.deepEqual(_.without.apply(_, [largeArray].concat(largeArray)), []);
7544 var result = _[methodName]({}, source);
7550 actual = _.groupBy([{ 'a': '__proto__' }], 'a');
7558 _.merge({}, JSON.parse('{"__proto__":{"a":1}}'));
7572 _.merge({}, { 'toString': { 'constructor': { 'prototype': { 'a': 1 } } } });
7579 _.merge({}, { 'constructor': { 'prototype': { 'a': 1 } } });
7590 _.merge({}, { 'constructor': { 'a': 1 } });
7609 actual = _.fromPairs(array);
7621 return index ? _.fromPairs(array) : _.fromPairs();
7631 var actual = _.fromPairs([['a.b', 1]]);
7639 assert.deepEqual(_.fromPairs(_.toPairs(object)), object);
7650 var actual = _(array).fromPairs().map(square).filter(isEven).take().value();
7652 assert.deepEqual(actual, _.take(_.filter(_.map(_.fromPairs(array), square), isEven)));
7669 actual = _.functions(object).sort();
7683 assert.deepEqual(_.functions(new Foo), ['a']);
7697 var actual = _.groupBy(array, Math.floor);
7709 return index ? _.groupBy(array, value) : _.groupBy(array);
7718 var actual = _.groupBy(['one', 'two', 'three'], 'length');
7725 var actual = _.groupBy(array, function(n) {
7742 assert.deepEqual(_.groupBy(array, 0), { '1': [[1, 'a']], '2': [[2, 'a'], [2, 'b']] });
7743 assert.deepEqual(_.groupBy(array, 1), { 'a': [[1, 'a'], [2, 'a']], 'b': [[2, 'b']] });
7749 var actual = _.groupBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
7764 actual = _(array).groupBy().map(iteratee).filter(predicate).take().value();
7766 …assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))…
7782 assert.strictEqual(_.gt(3, 1), true);
7783 assert.strictEqual(_.gt('def', 'abc'), true);
7789 assert.strictEqual(_.gt(1, 3), false);
7790 assert.strictEqual(_.gt(3, 3), false);
7791 assert.strictEqual(_.gt('abc', 'def'), false);
7792 assert.strictEqual(_.gt('def', 'def'), false);
7804 assert.strictEqual(_.gte(3, 1), true);
7805 assert.strictEqual(_.gte(3, 3), true);
7806 assert.strictEqual(_.gte('def', 'abc'), true);
7807 assert.strictEqual(_.gte('def', 'def'), true);
7813 assert.strictEqual(_.gte(1, 3), false);
7814 assert.strictEqual(_.gte('abc', 'def'), false);
7823 var func = _[methodName],
8069 assert.strictEqual(_.head(array), 1);
8076 assert.strictEqual(_.head([]), undefined);
8084 actual = lodashStable.map(array, _.head);
8092 assert.strictEqual(_.first, _.head);
8099 var wrapped = _(array);
8112 var wrapped = _(array).chain();
8113 assert.ok(wrapped.head() instanceof _);
8114 assert.ok(wrapped.first() instanceof _);
8125 var wrapped = _(array).chain();
8144 actual = _(array).filter(isEven)[methodName]();
8146 assert.strictEqual(actual, _[methodName](_.filter(array, isEven)));
8165 assert.strictEqual(_.identity(object), object);
8184 assert.strictEqual(_.includes(collection, 3), true);
8190 assert.strictEqual(_.includes(collection, 5), false);
8196 assert.strictEqual(_.includes(collection, 2, 1.2), true);
8203 assert.strictEqual(_(collection).includes(3), true);
8214 assert.ok(_(collection).chain().includes(3) instanceof _);
8230 assert.strictEqual(_.includes(collection, 'bc'), true);
8231 assert.strictEqual(_.includes(collection, 'd'), false);
8242 return _.includes(value);
8262 _.includes(string, 1, fromIndex),
8263 _.includes(string, undefined, fromIndex),
8264 _.includes(string, '', fromIndex)
8274 assert.strictEqual(_.includes([1, NaN, 3], NaN), true);
8280 assert.strictEqual(_.includes([-0], 0), true);
8281 assert.strictEqual(_.includes([0], -0), true);
8290 assert.ok(lodashStable.every(values, lodashStable.partial(_.includes, array)));
8308 return index ? _.initial(array) : _.initial();
8318 assert.deepEqual(_.initial(array), [1, 2]);
8324 assert.deepEqual(_.initial([]), []);
8331 actual = lodashStable.map(array, _.initial);
8343 var actual = _(array).initial().filter(function(value) {
8350 assert.deepEqual(values, _.initial(array));
8354 actual = _(array).filter(function(value) {
8361 assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven)));
8378 assert.strictEqual(_.inRange(3, 5), true);
8379 assert.strictEqual(_.inRange(5, 5), false);
8380 assert.strictEqual(_.inRange(6, 5), false);
8386 assert.strictEqual(_.inRange(1, 1, 5), true);
8387 assert.strictEqual(_.inRange(3, 1, 5), true);
8388 assert.strictEqual(_.inRange(0, 1, 5), false);
8389 assert.strictEqual(_.inRange(5, 1, 5), false);
8397 assert.strictEqual(_.inRange(0, value), false);
8398 assert.strictEqual(_.inRange(0, value, 1), true);
8400 assert.strictEqual(_.inRange(0), false);
8408 assert.strictEqual(_.inRange(2, 5, 1), true);
8409 assert.strictEqual(_.inRange(-3, -2, -6), true);
8415 assert.strictEqual(_.inRange(0.5, 5), true);
8416 assert.strictEqual(_.inRange(1.2, 1, 5), true);
8417 assert.strictEqual(_.inRange(5.2, 5), false);
8418 assert.strictEqual(_.inRange(0.5, 1, 5), false);
8425 _.inRange(0, '1'),
8426 _.inRange(0, '0', 1),
8427 _.inRange(0, 0, '1'),
8428 _.inRange(0, NaN, 1),
8429 _.inRange(-1, -1, NaN)
8441 var func = _[methodName];
8545 var wrapped = _([1, 3, 2])[methodName]([5, 2, 1, 4]);
8546 assert.ok(wrapped instanceof _);
8563 var actual = _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
8566 actual = _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
8575 _.intersectionBy([2.1, 1.2], [2.3, 3.4], function() {
8593 actual = _.intersectionWith(objects, others, lodashStable.isEqual);
8607 … return lodashStable.map(_.intersectionWith(array, other, lodashStable.eq), lodashStable.toString);
8623 actual = _.invert(object);
8626 assert.deepEqual(_.invert(actual), { 'a': '1', 'b': '2' });
8633 assert.deepEqual(_.invert(object), { 'hasOwnProperty': 'a', 'constructor': 'b' });
8640 assert.deepEqual(_.invert(object), { 'a': '0', 'b': '1', '2': 'length' });
8648 wrapped = _(object).invert();
8650 assert.ok(wrapped instanceof _);
8671 var actual = _.invertBy(object, function(value) {
8685 return index ? _.invertBy(object, value) : _.invertBy(object);
8697 assert.ok(lodashStable.isEqual(_.invertBy(object), expected));
8704 var wrapped = _(object).invertBy();
8706 assert.ok(wrapped instanceof _);
8724 actual = _.invoke(object, 'a');
8733 actual = _.invoke(object, 'a', 1, 2);
8746 return _.invoke(value, 'a.b', 1, 2);
8760 return _.invoke(object, key);
8772 var actual = _.invoke(object, path, 1, 2);
8783 assert.deepEqual(_.invoke(object, path), 1);
8792 assert.strictEqual(_(object).invoke('a'), 1);
8804 assert.ok(_(object).chain().invoke('a') instanceof _);
8821 actual = _.invokeMap(array, 'toUpperCase');
8830 actual = _.invokeMap(array, 'call', null, 'a', 'b', 'c');
8840 var actual = _.invokeMap(array, function(left, right) {
8851 actual = _.invokeMap(object, 'toFixed', 1);
8859 assert.deepEqual(_.invokeMap(1), []);
8868 var actual = _.invokeMap(array, 'toUpperCase');
8886 var actual = _.invokeMap(objects, 'a');
8898 assert.deepEqual(_.invokeMap([object], path), [1]);
8907 wrapped = _(array),
8910 assert.ok(actual instanceof _);
8917 assert.ok(actual instanceof _);
8936 var actual = _(array).invokeMap('method').take(1).value();
8955 assert.strictEqual(_.isArguments(args), true);
8956 assert.strictEqual(_.isArguments(strictArgs), true);
8965 return index ? _.isArguments(value) : _.isArguments();
8970 assert.strictEqual(_.isArguments([1, 2, 3]), false);
8971 assert.strictEqual(_.isArguments(true), false);
8972 assert.strictEqual(_.isArguments(new Date), false);
8973 assert.strictEqual(_.isArguments(new Error), false);
8974 assert.strictEqual(_.isArguments(_), false);
8975 assert.strictEqual(_.isArguments(slice), false);
8976 assert.strictEqual(_.isArguments({ '0': 1, 'callee': noop, 'length': 1 }), false);
8977 assert.strictEqual(_.isArguments(1), false);
8978 assert.strictEqual(_.isArguments(/x/), false);
8979 assert.strictEqual(_.isArguments('a'), false);
8980 assert.strictEqual(_.isArguments(symbol), false);
8987 assert.strictEqual(_.isArguments(realm.arguments), true);
9003 assert.strictEqual(_.isArray([1, 2, 3]), true);
9012 return index ? _.isArray(value) : _.isArray();
9017 assert.strictEqual(_.isArray(args), false);
9018 assert.strictEqual(_.isArray(true), false);
9019 assert.strictEqual(_.isArray(new Date), false);
9020 assert.strictEqual(_.isArray(new Error), false);
9021 assert.strictEqual(_.isArray(_), false);
9022 assert.strictEqual(_.isArray(slice), false);
9023 assert.strictEqual(_.isArray({ '0': 1, 'length': 1 }), false);
9024 assert.strictEqual(_.isArray(1), false);
9025 assert.strictEqual(_.isArray(/x/), false);
9026 assert.strictEqual(_.isArray('a'), false);
9027 assert.strictEqual(_.isArray(symbol), false);
9034 assert.strictEqual(_.isArray(realm.array), true);
9051 assert.strictEqual(_.isArrayBuffer(arrayBuffer), true);
9064 return index ? _.isArrayBuffer(value) : _.isArrayBuffer();
9069 assert.strictEqual(_.isArrayBuffer(args), false);
9070 assert.strictEqual(_.isArrayBuffer([1]), false);
9071 assert.strictEqual(_.isArrayBuffer(true), false);
9072 assert.strictEqual(_.isArrayBuffer(new Date), false);
9073 assert.strictEqual(_.isArrayBuffer(new Error), false);
9074 assert.strictEqual(_.isArrayBuffer(_), false);
9075 assert.strictEqual(_.isArrayBuffer(slice), false);
9076 assert.strictEqual(_.isArrayBuffer({ 'a': 1 }), false);
9077 assert.strictEqual(_.isArrayBuffer(1), false);
9078 assert.strictEqual(_.isArrayBuffer(/x/), false);
9079 assert.strictEqual(_.isArrayBuffer('a'), false);
9080 assert.strictEqual(_.isArrayBuffer(symbol), false);
9087 assert.strictEqual(_.isArrayBuffer(realm.arrayBuffer), true);
9105 actual = lodashStable.map(values, _.isArrayLike);
9118 return index ? _.isArrayLike(value) : _.isArrayLike();
9123 assert.strictEqual(_.isArrayLike(true), false);
9124 assert.strictEqual(_.isArrayLike(new Date), false);
9125 assert.strictEqual(_.isArrayLike(new Error), false);
9126 assert.strictEqual(_.isArrayLike(_), false);
9127 assert.strictEqual(_.isArrayLike(asyncFunc), false);
9128 assert.strictEqual(_.isArrayLike(genFunc), false);
9129 assert.strictEqual(_.isArrayLike(slice), false);
9130 assert.strictEqual(_.isArrayLike({ 'a': 1 }), false);
9131 assert.strictEqual(_.isArrayLike(1), false);
9132 assert.strictEqual(_.isArrayLike(/x/), false);
9133 assert.strictEqual(_.isArrayLike(symbol), false);
9142 actual = lodashStable.map(values, _.isArrayLike);
9160 assert.strictEqual(_.isBoolean(true), true);
9161 assert.strictEqual(_.isBoolean(false), true);
9162 assert.strictEqual(_.isBoolean(Object(true)), true);
9163 assert.strictEqual(_.isBoolean(Object(false)), true);
9174 return index ? _.isBoolean(value) : _.isBoolean();
9179 assert.strictEqual(_.isBoolean(args), false);
9180 assert.strictEqual(_.isBoolean([1, 2, 3]), false);
9181 assert.strictEqual(_.isBoolean(new Date), false);
9182 assert.strictEqual(_.isBoolean(new Error), false);
9183 assert.strictEqual(_.isBoolean(_), false);
9184 assert.strictEqual(_.isBoolean(slice), false);
9185 assert.strictEqual(_.isBoolean({ 'a': 1 }), false);
9186 assert.strictEqual(_.isBoolean(1), false);
9187 assert.strictEqual(_.isBoolean(/x/), false);
9188 assert.strictEqual(_.isBoolean('a'), false);
9189 assert.strictEqual(_.isBoolean(symbol), false);
9196 assert.strictEqual(_.isBoolean(realm.boolean), true);
9213 assert.strictEqual(_.isBuffer(new Buffer(2)), true);
9226 return index ? _.isBuffer(value) : _.isBuffer();
9231 assert.strictEqual(_.isBuffer(args), false);
9232 assert.strictEqual(_.isBuffer([1]), false);
9233 assert.strictEqual(_.isBuffer(true), false);
9234 assert.strictEqual(_.isBuffer(new Date), false);
9235 assert.strictEqual(_.isBuffer(new Error), false);
9236 assert.strictEqual(_.isBuffer(_), false);
9237 assert.strictEqual(_.isBuffer(slice), false);
9238 assert.strictEqual(_.isBuffer({ 'a': 1 }), false);
9239 assert.strictEqual(_.isBuffer(1), false);
9240 assert.strictEqual(_.isBuffer(/x/), false);
9241 assert.strictEqual(_.isBuffer('a'), false);
9242 assert.strictEqual(_.isBuffer(symbol), false);
9265 assert.strictEqual(_.isDate(new Date), true);
9274 return index ? _.isDate(value) : _.isDate();
9279 assert.strictEqual(_.isDate(args), false);
9280 assert.strictEqual(_.isDate([1, 2, 3]), false);
9281 assert.strictEqual(_.isDate(true), false);
9282 assert.strictEqual(_.isDate(new Error), false);
9283 assert.strictEqual(_.isDate(_), false);
9284 assert.strictEqual(_.isDate(slice), false);
9285 assert.strictEqual(_.isDate({ 'a': 1 }), false);
9286 assert.strictEqual(_.isDate(1), false);
9287 assert.strictEqual(_.isDate(/x/), false);
9288 assert.strictEqual(_.isDate('a'), false);
9289 assert.strictEqual(_.isDate(symbol), false);
9296 assert.strictEqual(_.isDate(realm.date), true);
9313 assert.strictEqual(_.isElement(body), true);
9327 assert.strictEqual(_.isElement(new Foo), true);
9336 return index ? _.isElement(value) : _.isElement();
9341 assert.strictEqual(_.isElement(args), false);
9342 assert.strictEqual(_.isElement([1, 2, 3]), false);
9343 assert.strictEqual(_.isElement(true), false);
9344 assert.strictEqual(_.isElement(new Date), false);
9345 assert.strictEqual(_.isElement(new Error), false);
9346 assert.strictEqual(_.isElement(_), false);
9347 assert.strictEqual(_.isElement(slice), false);
9348 assert.strictEqual(_.isElement({ 'a': 1 }), false);
9349 assert.strictEqual(_.isElement(1), false);
9350 assert.strictEqual(_.isElement(/x/), false);
9351 assert.strictEqual(_.isElement('a'), false);
9352 assert.strictEqual(_.isElement(symbol), false);
9358 assert.strictEqual(_.isElement({ 'nodeType': 1 }), false);
9359 assert.strictEqual(_.isElement({ 'nodeType': Object(1) }), false);
9360 assert.strictEqual(_.isElement({ 'nodeType': true }), false);
9361 assert.strictEqual(_.isElement({ 'nodeType': [1] }), false);
9362 assert.strictEqual(_.isElement({ 'nodeType': '1' }), false);
9363 assert.strictEqual(_.isElement({ 'nodeType': '001' }), false);
9370 assert.strictEqual(_.isElement(realm.element), true);
9387 actual = lodashStable.map(empties, _.isEmpty);
9391 assert.strictEqual(_.isEmpty(true), true);
9392 assert.strictEqual(_.isEmpty(slice), true);
9393 assert.strictEqual(_.isEmpty(1), true);
9394 assert.strictEqual(_.isEmpty(NaN), true);
9395 assert.strictEqual(_.isEmpty(/x/), true);
9396 assert.strictEqual(_.isEmpty(symbol), true);
9397 assert.strictEqual(_.isEmpty(), true);
9400 assert.strictEqual(_.isEmpty(new Buffer(0)), true);
9401 assert.strictEqual(_.isEmpty(new Buffer(1)), false);
9411 assert.strictEqual(_.isEmpty([0]), false);
9412 assert.strictEqual(_.isEmpty({ 'a': 0 }), false);
9413 assert.strictEqual(_.isEmpty('a'), false);
9419 assert.strictEqual(_.isEmpty({ 'length': 0 }), false);
9425 assert.strictEqual(_.isEmpty(args), false);
9434 assert.strictEqual(_.isEmpty(Foo.prototype), true);
9437 assert.strictEqual(_.isEmpty(Foo.prototype), false);
9448 assert.strictEqual(_.isEmpty(new Foo([])), true);
9456 assert.strictEqual(_.isEmpty(map), true);
9458 assert.strictEqual(_.isEmpty(map), false);
9472 assert.strictEqual(_.isEmpty(set), true);
9474 assert.strictEqual(_.isEmpty(set), false);
9489 assert.strictEqual(_.isEmpty(new Foo), true);
9498 assert.strictEqual(_.isEmpty(new Foo), true);
9504 assert.strictEqual(_.isEmpty({ 'length': '0' }), false);
9511 assert.strictEqual(_({}).isEmpty(), true);
9522 assert.ok(_({}).chain().isEmpty() instanceof _);
9558 return _.isEqual(pair[0], pair[1]);
9570 assert.strictEqual(_.isEqual(array1, array2), true);
9575 assert.strictEqual(_.isEqual(array1, array2), true);
9584 assert.strictEqual(_.isEqual(array1, array2), true);
9589 assert.strictEqual(_.isEqual(array1, array2), true);
9594 assert.strictEqual(_.isEqual(array1, array2), false);
9599 assert.strictEqual(_.isEqual(array1, array2), false);
9616 assert.strictEqual(_.isEqual(array1, array2), true);
9624 assert.strictEqual(_.isEqual(array1, array2), true);
9629 assert.strictEqual(_.isEqual(array1, array2), true);
9637 assert.strictEqual(_.isEqual(array, Array(1)), true);
9638 assert.strictEqual(_.isEqual(array, [undefined]), true);
9639 assert.strictEqual(_.isEqual(array, Array(2)), false);
9648 assert.strictEqual(_.isEqual(object1, object2), true);
9653 assert.strictEqual(_.isEqual(object1, object2), true);
9658 assert.strictEqual(_.isEqual(object1, object2), false);
9663 assert.strictEqual(_.isEqual(object1, object2), false);
9668 assert.strictEqual(_.isEqual(object1, object2), false);
9677 assert.strictEqual(_.isEqual(object1, object2), true);
9711 assert.strictEqual(_.isEqual(object1, object2), true);
9727 assert.strictEqual(_.isEqual(new Foo, new Foo), true);
9728 assert.strictEqual(_.isEqual(new Foo, new Bar), false);
9729 assert.strictEqual(_.isEqual({ 'a': 1 }, new Foo), false);
9730 assert.strictEqual(_.isEqual({ 'a': 2 }, new Bar), false);
9736 assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': 1 }), true);
9737 assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': '1' }), false);
9738 assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': [1] }), true);
9739 assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': ['1'] }), false);
9740 assert.strictEqual(_.isEqual({ 'constructor': Object }, {}), false);
9752 assert.strictEqual(_.isEqual(array1, array2), true);
9757 assert.strictEqual(_.isEqual(array1, array2), true);
9762 assert.strictEqual(_.isEqual(array1, array2), false);
9768 assert.strictEqual(_.isEqual(array1, array2), false);
9780 assert.strictEqual(_.isEqual(array1, array2), true);
9781 assert.strictEqual(_.isEqual(array2, array3), true);
9782 assert.strictEqual(_.isEqual(array1, array3), true);
9794 assert.strictEqual(_.isEqual(object1, object2), true);
9799 assert.strictEqual(_.isEqual(object1, object2), true);
9804 assert.strictEqual(_.isEqual(object1, object2), false);
9810 assert.strictEqual(_.isEqual(object1, object2), false);
9822 assert.strictEqual(_.isEqual(object1, object2), true);
9823 assert.strictEqual(_.isEqual(object2, object3), true);
9824 assert.strictEqual(_.isEqual(object1, object3), true);
9836 assert.strictEqual(_.isEqual(array1, array2), true);
9841 assert.strictEqual(_.isEqual(array1, array2), true);
9846 assert.strictEqual(_.isEqual(array1, array2), false);
9868 assert.strictEqual(_.isEqual(object1, object2), true);
9885 assert.strictEqual(_.isEqual(object1, object2), true);
9901 assert.strictEqual(_.isEqual(object1, object2), true);
9902 assert.strictEqual(_.isEqual(new Foo, object2), false);
9908 assert.strictEqual(_.isEqual(true, Object(false)), false);
9909 assert.strictEqual(_.isEqual(Object(false), Object(0)), false);
9910 assert.strictEqual(_.isEqual(false, Object('')), false);
9911 assert.strictEqual(_.isEqual(Object(36), Object('36')), false);
9912 assert.strictEqual(_.isEqual(0, ''), false);
9913 assert.strictEqual(_.isEqual(1, true), false);
9914 assert.strictEqual(_.isEqual(1337756400000, new Date(2012, 4, 23)), false);
9915 assert.strictEqual(_.isEqual('36', 36), false);
9916 assert.strictEqual(_.isEqual(36, '36'), false);
9926 assert.strictEqual(_.isEqual(args1, args2), true);
9927 assert.strictEqual(_.isEqual(args1, args3), false);
9938 assert.strictEqual(_.isEqual(args, object), true);
9939 assert.strictEqual(_.isEqual(object, args), true);
9940 assert.strictEqual(_.isEqual(args, new Foo), false);
9941 assert.strictEqual(_.isEqual(new Foo, args), false);
9950 assert.strictEqual(_.isEqual(buffer, new Uint8Array([255]).buffer), true);
9951 assert.strictEqual(_.isEqual(buffer, new ArrayBuffer(1)), false);
9978 … return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])];
9991 assert.strictEqual(_.isEqual(buffer, new Buffer([1])), true);
9992 assert.strictEqual(_.isEqual(buffer, new Buffer([2])), false);
9993 assert.strictEqual(_.isEqual(buffer, new Uint8Array([1])), false);
10005 assert.strictEqual(_.isEqual(date, new Date(2012, 4, 23)), true);
10006 assert.strictEqual(_.isEqual(new Date('a'), new Date('b')), true);
10007 assert.strictEqual(_.isEqual(date, new Date(2013, 3, 25)), false);
10008 assert.strictEqual(_.isEqual(date, { 'getTime': lodashStable.constant(+date) }), false);
10033 … return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])];
10045 assert.strictEqual(_.isEqual(a, a), true);
10046 assert.strictEqual(_.isEqual(a, b), false);
10059 assert.strictEqual(_.isEqual(map1, map2), false);
10063 assert.strictEqual(_.isEqual(map1, map2), true);
10067 assert.strictEqual(_.isEqual(map1, map2), true);
10070 assert.strictEqual(_.isEqual(map1, map2), false);
10090 assert.strictEqual(_.isEqual(map1, map2), true);
10094 assert.strictEqual(_.isEqual(map1, map2), false);
10109 assert.strictEqual(_.isEqual(promise1, promise2), false);
10110 assert.strictEqual(_.isEqual(promise1, promise1), true);
10121 assert.strictEqual(_.isEqual(/x/gim, /x/gim), true);
10122 assert.strictEqual(_.isEqual(/x/gim, /x/mgi), true);
10123 assert.strictEqual(_.isEqual(/x/gi, /x/g), false);
10124 assert.strictEqual(_.isEqual(/x/, /y/), false);
10125 …assert.strictEqual(_.isEqual(/x/g, { 'global': true, 'ignoreCase': false, 'multiline': false, 'sou…
10138 assert.strictEqual(_.isEqual(set1, set2), false);
10142 assert.strictEqual(_.isEqual(set1, set2), true);
10146 assert.strictEqual(_.isEqual(set1, set2), true);
10149 assert.strictEqual(_.isEqual(set1, set2), false);
10169 assert.strictEqual(_.isEqual(set1, set2), true);
10173 assert.strictEqual(_.isEqual(set1, set2), false);
10197 assert.strictEqual(_.isEqual(object1, object2), true);
10200 assert.strictEqual(_.isEqual(object1, object2), false);
10204 assert.strictEqual(_.isEqual(object1, object2), false);
10229 var wrapped1 = _(vals[0]),
10230 wrapped2 = _(vals[1]),
10234 assert.strictEqual(_.isEqual(_(actual), _(true)), true);
10236 wrapped1 = _(vals[0]);
10237 wrapped2 = _(vals[2]);
10241 assert.strictEqual(_.isEqual(_(actual), _(false)), true);
10253 var object1 = _({ 'a': 1, 'b': 2 }),
10257 assert.strictEqual(_.isEqual(object1, object2), true);
10259 object1 = _({ 'a': 1, 'b': 2 });
10263 assert.strictEqual(_.isEqual(object1, object2), false);
10273 var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
10285 assert.strictEqual(_.isEqual(element1, element2), false);
10299 assert.strictEqual(_.isEqual([1], realm.array), true);
10300 assert.strictEqual(_.isEqual([2], realm.array), false);
10301 assert.strictEqual(_.isEqual({ 'a': 1 }, realm.object), true);
10302 assert.strictEqual(_.isEqual({ 'a': 2 }, realm.object), false);
10319 return _.isEqual(object, value);
10329 assert.strictEqual(_('a').isEqual('a'), true);
10340 assert.ok(_('a').chain().isEqual('a') instanceof _);
10371 _.isEqualWith(object1, object2, function(assert) {
10384 assert.strictEqual(_.isEqualWith('a', 'a', noop), true);
10385 assert.strictEqual(_.isEqualWith(['a'], ['a'], noop), true);
10386 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, noop), true);
10393 return _.isString(value) || undefined;
10396 assert.strictEqual(_.isEqualWith('a', 'b', customizer), true);
10397 assert.strictEqual(_.isEqualWith(['a'], ['b'], customizer), true);
10398 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
10405 return _.isString(value) ? false : undefined;
10408 assert.strictEqual(_.isEqualWith('a', 'a', customizer), false);
10409 assert.strictEqual(_.isEqualWith(['a'], ['a'], customizer), false);
10410 assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
10416 var actual = _.isEqualWith('a', 'b', stubC);
10419 var values = _.without(falsey, undefined),
10424 actual.push(_.isEqualWith('a', 'a', lodashStable.constant(value)));
10434 eq = _.partial(_.isEqualWith, array),
10474 _.isEqualWith(pair[0], pair[1], function() {
10501 return _.isError(error) === true;
10510 assert.strictEqual(_.isError(new CustomError('x')), true);
10519 return index ? _.isError(value) : _.isError();
10524 assert.strictEqual(_.isError(args), false);
10525 assert.strictEqual(_.isError([1, 2, 3]), false);
10526 assert.strictEqual(_.isError(true), false);
10527 assert.strictEqual(_.isError(new Date), false);
10528 assert.strictEqual(_.isError(_), false);
10529 assert.strictEqual(_.isError(slice), false);
10530 assert.strictEqual(_.isError({ 'a': 1 }), false);
10531 assert.strictEqual(_.isError(1), false);
10532 assert.strictEqual(_.isError(/x/), false);
10533 assert.strictEqual(_.isError('a'), false);
10534 assert.strictEqual(_.isError(symbol), false);
10540 assert.strictEqual(_.isError({ 'name': 'Error', 'message': '' }), false);
10550 return _.isError(error) === true;
10571 actual = lodashStable.map(values, _.isFinite);
10581 actual = lodashStable.map(values, _.isFinite);
10591 actual = lodashStable.map(values, _.isFinite);
10595 assert.strictEqual(_.isFinite(args), false);
10596 assert.strictEqual(_.isFinite([1, 2, 3]), false);
10597 assert.strictEqual(_.isFinite(true), false);
10598 assert.strictEqual(_.isFinite(new Date), false);
10599 assert.strictEqual(_.isFinite(new Error), false);
10600 assert.strictEqual(_.isFinite({ 'a': 1 }), false);
10601 assert.strictEqual(_.isFinite(/x/), false);
10602 assert.strictEqual(_.isFinite('a'), false);
10603 assert.strictEqual(_.isFinite(symbol), false);
10611 actual = lodashStable.map(values, _.isFinite);
10625 assert.strictEqual(_.isFunction(_), true);
10626 assert.strictEqual(_.isFunction(slice), true);
10632 assert.strictEqual(_.isFunction(asyncFunc), typeof asyncFunc == 'function');
10638 assert.strictEqual(_.isFunction(genFunc), typeof genFunc == 'function');
10645 assert.strictEqual(_.isFunction(Proxy), true);
10660 return _.isFunction(root[type]);
10672 return index ? _.isFunction(value) : _.isFunction();
10677 assert.strictEqual(_.isFunction(args), false);
10678 assert.strictEqual(_.isFunction([1, 2, 3]), false);
10679 assert.strictEqual(_.isFunction(true), false);
10680 assert.strictEqual(_.isFunction(new Date), false);
10681 assert.strictEqual(_.isFunction(new Error), false);
10682 assert.strictEqual(_.isFunction({ 'a': 1 }), false);
10683 assert.strictEqual(_.isFunction(1), false);
10684 assert.strictEqual(_.isFunction(/x/), false);
10685 assert.strictEqual(_.isFunction('a'), false);
10686 assert.strictEqual(_.isFunction(symbol), false);
10689 assert.strictEqual(_.isFunction(document.getElementsByTagName('body')), false);
10700 assert.strictEqual(_.isFunction(realm.function), true);
10713 var func = _[methodName],
10778 actual = lodashStable.map(values, _.isLength);
10788 actual = lodashStable.map(values, _.isLength);
10803 assert.strictEqual(_.isMap(map), true);
10816 return index ? _.isMap(value) : _.isMap();
10821 assert.strictEqual(_.isMap(args), false);
10822 assert.strictEqual(_.isMap([1, 2, 3]), false);
10823 assert.strictEqual(_.isMap(true), false);
10824 assert.strictEqual(_.isMap(new Date), false);
10825 assert.strictEqual(_.isMap(new Error), false);
10826 assert.strictEqual(_.isMap(_), false);
10827 assert.strictEqual(_.isMap(slice), false);
10828 assert.strictEqual(_.isMap({ 'a': 1 }), false);
10829 assert.strictEqual(_.isMap(1), false);
10830 assert.strictEqual(_.isMap(/x/), false);
10831 assert.strictEqual(_.isMap('a'), false);
10832 assert.strictEqual(_.isMap(symbol), false);
10833 assert.strictEqual(_.isMap(weakMap), false);
10843 return _.isMap({ 'constructor': value });
10853 assert.strictEqual(_.isMap(realm.map), true);
10887 _.isMatchWith(object1, object2, function(assert) {
10897 assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, noop), true);
10904 return _.isString(value) || undefined;
10907 assert.strictEqual(_.isMatchWith(['a'], ['b'], customizer), true);
10908 assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'b' }, customizer), true);
10915 return _.isString(value) ? false : undefined;
10918 assert.strictEqual(_.isMatchWith(['a'], ['a'], customizer), false);
10919 assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'a' }, customizer), false);
10926 actual = _.isMatchWith(object, { 'a': 1 }, stubA);
10934 actual.push(_.isMatchWith(object, { 'a': 2 }, lodashStable.constant(value)));
10945 _.isMatchWith({ 'a': 1 }, { 'a': 1 }, function() {
10946 actual = _.last(arguments);
10959 matches = _.partial(_.isMatchWith, object),
11001 _.isMatchWith({ 'a': pair[0] }, { 'a': pair[1] }, function() {
11022 assert.strictEqual(_.isNaN(NaN), true);
11023 assert.strictEqual(_.isNaN(Object(NaN)), true);
11034 return index ? _.isNaN(value) : _.isNaN();
11039 assert.strictEqual(_.isNaN(args), false);
11040 assert.strictEqual(_.isNaN([1, 2, 3]), false);
11041 assert.strictEqual(_.isNaN(true), false);
11042 assert.strictEqual(_.isNaN(new Date), false);
11043 assert.strictEqual(_.isNaN(new Error), false);
11044 assert.strictEqual(_.isNaN(_), false);
11045 assert.strictEqual(_.isNaN(slice), false);
11046 assert.strictEqual(_.isNaN({ 'a': 1 }), false);
11047 assert.strictEqual(_.isNaN(1), false);
11048 assert.strictEqual(_.isNaN(Object(1)), false);
11049 assert.strictEqual(_.isNaN(/x/), false);
11050 assert.strictEqual(_.isNaN('a'), false);
11051 assert.strictEqual(_.isNaN(symbol), false);
11058 assert.strictEqual(_.isNaN(realm.nan), true);
11076 actual = lodashStable.map(values, _.isNative);
11087 return index ? _.isNative(value) : _.isNative();
11092 assert.strictEqual(_.isNative(args), false);
11093 assert.strictEqual(_.isNative([1, 2, 3]), false);
11094 assert.strictEqual(_.isNative(true), false);
11095 assert.strictEqual(_.isNative(new Date), false);
11096 assert.strictEqual(_.isNative(new Error), false);
11097 assert.strictEqual(_.isNative(_), false);
11098 assert.strictEqual(_.isNative({ 'a': 1 }), false);
11099 assert.strictEqual(_.isNative(1), false);
11100 assert.strictEqual(_.isNative(/x/), false);
11101 assert.strictEqual(_.isNative('a'), false);
11102 assert.strictEqual(_.isNative(symbol), false);
11109 assert.strictEqual(_.isNative(realm.element.cloneNode), true);
11115 assert.strictEqual(_.isNative(realm.object.valueOf), true);
11126 var lodash = _.runInContext({
11140 if (!amd && _._baseEach) {
11173 assert.strictEqual(_.isNil(null), true);
11174 assert.strictEqual(_.isNil(), true);
11175 assert.strictEqual(_.isNil(undefined), true);
11186 return index ? _.isNil(value) : _.isNil();
11191 assert.strictEqual(_.isNil(args), false);
11192 assert.strictEqual(_.isNil([1, 2, 3]), false);
11193 assert.strictEqual(_.isNil(true), false);
11194 assert.strictEqual(_.isNil(new Date), false);
11195 assert.strictEqual(_.isNil(new Error), false);
11196 assert.strictEqual(_.isNil(_), false);
11197 assert.strictEqual(_.isNil(slice), false);
11198 assert.strictEqual(_.isNil({ 'a': 1 }), false);
11199 assert.strictEqual(_.isNil(1), false);
11200 assert.strictEqual(_.isNil(/x/), false);
11201 assert.strictEqual(_.isNil('a'), false);
11204 assert.strictEqual(_.isNil(symbol), false);
11215 assert.strictEqual(_.isNil(realm.null), true);
11216 assert.strictEqual(_.isNil(realm.undefined), true);
11232 assert.strictEqual(_.isNull(null), true);
11243 return index ? _.isNull(value) : _.isNull();
11248 assert.strictEqual(_.isNull(args), false);
11249 assert.strictEqual(_.isNull([1, 2, 3]), false);
11250 assert.strictEqual(_.isNull(true), false);
11251 assert.strictEqual(_.isNull(new Date), false);
11252 assert.strictEqual(_.isNull(new Error), false);
11253 assert.strictEqual(_.isNull(_), false);
11254 assert.strictEqual(_.isNull(slice), false);
11255 assert.strictEqual(_.isNull({ 'a': 1 }), false);
11256 assert.strictEqual(_.isNull(1), false);
11257 assert.strictEqual(_.isNull(/x/), false);
11258 assert.strictEqual(_.isNull('a'), false);
11259 assert.strictEqual(_.isNull(symbol), false);
11266 assert.strictEqual(_.isNull(realm.null), true);
11282 assert.strictEqual(_.isNumber(0), true);
11283 assert.strictEqual(_.isNumber(Object(0)), true);
11284 assert.strictEqual(_.isNumber(NaN), true);
11295 return index ? _.isNumber(value) : _.isNumber();
11300 assert.strictEqual(_.isNumber(args), false);
11301 assert.strictEqual(_.isNumber([1, 2, 3]), false);
11302 assert.strictEqual(_.isNumber(true), false);
11303 assert.strictEqual(_.isNumber(new Date), false);
11304 assert.strictEqual(_.isNumber(new Error), false);
11305 assert.strictEqual(_.isNumber(_), false);
11306 assert.strictEqual(_.isNumber(slice), false);
11307 assert.strictEqual(_.isNumber({ 'a': 1 }), false);
11308 assert.strictEqual(_.isNumber(/x/), false);
11309 assert.strictEqual(_.isNumber('a'), false);
11310 assert.strictEqual(_.isNumber(symbol), false);
11317 assert.strictEqual(_.isNumber(realm.number), true);
11333 assert.strictEqual(_.isObject(args), true);
11334 assert.strictEqual(_.isObject([1, 2, 3]), true);
11335 assert.strictEqual(_.isObject(Object(false)), true);
11336 assert.strictEqual(_.isObject(new Date), true);
11337 assert.strictEqual(_.isObject(new Error), true);
11338 assert.strictEqual(_.isObject(_), true);
11339 assert.strictEqual(_.isObject(slice), true);
11340 assert.strictEqual(_.isObject({ 'a': 1 }), true);
11341 assert.strictEqual(_.isObject(Object(0)), true);
11342 assert.strictEqual(_.isObject(/x/), true);
11343 assert.strictEqual(_.isObject(Object('a')), true);
11346 assert.strictEqual(_.isObject(body), true);
11352 assert.strictEqual(_.isObject(Object(symbol)), true);
11366 return index ? _.isObject(value) : _.isObject();
11376 assert.strictEqual(_.isObject(realm.element), true);
11382 assert.strictEqual(_.isObject(realm.boolean), true);
11383 assert.strictEqual(_.isObject(realm.date), true);
11384 assert.strictEqual(_.isObject(realm.function), true);
11385 assert.strictEqual(_.isObject(realm.number), true);
11386 assert.strictEqual(_.isObject(realm.object), true);
11387 assert.strictEqual(_.isObject(realm.regexp), true);
11388 assert.strictEqual(_.isObject(realm.string), true);
11404 assert.strictEqual(_.isObjectLike(args), true);
11405 assert.strictEqual(_.isObjectLike([1, 2, 3]), true);
11406 assert.strictEqual(_.isObjectLike(Object(false)), true);
11407 assert.strictEqual(_.isObjectLike(new Date), true);
11408 assert.strictEqual(_.isObjectLike(new Error), true);
11409 assert.strictEqual(_.isObjectLike({ 'a': 1 }), true);
11410 assert.strictEqual(_.isObjectLike(Object(0)), true);
11411 assert.strictEqual(_.isObjectLike(/x/), true);
11412 assert.strictEqual(_.isObjectLike(Object('a')), true);
11418 var values = falsey.concat(true, _, slice, 1, 'a', symbol),
11422 return index ? _.isObjectLike(value) : _.isObjectLike();
11432 assert.strictEqual(_.isObjectLike(realm.boolean), true);
11433 assert.strictEqual(_.isObjectLike(realm.date), true);
11434 assert.strictEqual(_.isObjectLike(realm.number), true);
11435 assert.strictEqual(_.isObjectLike(realm.object), true);
11436 assert.strictEqual(_.isObjectLike(realm.regexp), true);
11437 assert.strictEqual(_.isObjectLike(realm.string), true);
11459 assert.strictEqual(_.isPlainObject({}), true);
11460 assert.strictEqual(_.isPlainObject({ 'a': 1 }), true);
11461 assert.strictEqual(_.isPlainObject({ 'constructor': Foo }), true);
11462 assert.strictEqual(_.isPlainObject([1, 2, 3]), false);
11463 assert.strictEqual(_.isPlainObject(new Foo(1)), false);
11470 assert.strictEqual(_.isPlainObject(object), true);
11473 assert.strictEqual(_.isPlainObject(object), true);
11479 assert.strictEqual(_.isPlainObject({ 'valueOf': 0 }), true);
11489 assert.deepEqual(_.isPlainObject(object), true);
11500 assert.strictEqual(_.isPlainObject(object), false);
11507 assert.strictEqual(_.isPlainObject(element), false);
11516 assert.strictEqual(_.isPlainObject(arguments), false);
11517 assert.strictEqual(_.isPlainObject(Error), false);
11518 assert.strictEqual(_.isPlainObject(Math), false);
11527 return index ? _.isPlainObject(value) : _.isPlainObject();
11532 assert.strictEqual(_.isPlainObject(true), false);
11533 assert.strictEqual(_.isPlainObject('a'), false);
11534 assert.strictEqual(_.isPlainObject(symbol), false);
11549 assert.deepEqual(_.isPlainObject(object), false);
11564 assert.strictEqual(_.isPlainObject(object), false);
11576 assert.strictEqual(_.isPlainObject(realm.object), true);
11592 assert.strictEqual(_.isRegExp(/x/), true);
11593 assert.strictEqual(_.isRegExp(RegExp('x')), true);
11602 return index ? _.isRegExp(value) : _.isRegExp();
11607 assert.strictEqual(_.isRegExp(args), false);
11608 assert.strictEqual(_.isRegExp([1, 2, 3]), false);
11609 assert.strictEqual(_.isRegExp(true), false);
11610 assert.strictEqual(_.isRegExp(new Date), false);
11611 assert.strictEqual(_.isRegExp(new Error), false);
11612 assert.strictEqual(_.isRegExp(_), false);
11613 assert.strictEqual(_.isRegExp(slice), false);
11614 assert.strictEqual(_.isRegExp({ 'a': 1 }), false);
11615 assert.strictEqual(_.isRegExp(1), false);
11616 assert.strictEqual(_.isRegExp('a'), false);
11617 assert.strictEqual(_.isRegExp(symbol), false);
11624 assert.strictEqual(_.isRegExp(realm.regexp), true);
11641 assert.strictEqual(_.isSet(set), true);
11654 return index ? _.isSet(value) : _.isSet();
11659 assert.strictEqual(_.isSet(args), false);
11660 assert.strictEqual(_.isSet([1, 2, 3]), false);
11661 assert.strictEqual(_.isSet(true), false);
11662 assert.strictEqual(_.isSet(new Date), false);
11663 assert.strictEqual(_.isSet(new Error), false);
11664 assert.strictEqual(_.isSet(_), false);
11665 assert.strictEqual(_.isSet(slice), false);
11666 assert.strictEqual(_.isSet({ 'a': 1 }), false);
11667 assert.strictEqual(_.isSet(1), false);
11668 assert.strictEqual(_.isSet(/x/), false);
11669 assert.strictEqual(_.isSet('a'), false);
11670 assert.strictEqual(_.isSet(symbol), false);
11671 assert.strictEqual(_.isSet(weakSet), false);
11681 return _.isSet({ 'constructor': value });
11691 assert.strictEqual(_.isSet(realm.set), true);
11707 assert.strictEqual(_.isString('a'), true);
11708 assert.strictEqual(_.isString(Object('a')), true);
11719 return index ? _.isString(value) : _.isString();
11724 assert.strictEqual(_.isString(args), false);
11725 assert.strictEqual(_.isString([1, 2, 3]), false);
11726 assert.strictEqual(_.isString(true), false);
11727 assert.strictEqual(_.isString(new Date), false);
11728 assert.strictEqual(_.isString(new Error), false);
11729 assert.strictEqual(_.isString(_), false);
11730 assert.strictEqual(_.isString(slice), false);
11731 assert.strictEqual(_.isString({ '0': 1, 'length': 1 }), false);
11732 assert.strictEqual(_.isString(1), false);
11733 assert.strictEqual(_.isString(/x/), false);
11734 assert.strictEqual(_.isString(symbol), false);
11741 assert.strictEqual(_.isString(realm.string), true);
11758 assert.strictEqual(_.isSymbol(symbol), true);
11759 assert.strictEqual(_.isSymbol(Object(symbol)), true);
11772 return index ? _.isSymbol(value) : _.isSymbol();
11777 assert.strictEqual(_.isSymbol(args), false);
11778 assert.strictEqual(_.isSymbol([1, 2, 3]), false);
11779 assert.strictEqual(_.isSymbol(true), false);
11780 assert.strictEqual(_.isSymbol(new Date), false);
11781 assert.strictEqual(_.isSymbol(new Error), false);
11782 assert.strictEqual(_.isSymbol(_), false);
11783 assert.strictEqual(_.isSymbol(slice), false);
11784 assert.strictEqual(_.isSymbol({ '0': 1, 'length': 1 }), false);
11785 assert.strictEqual(_.isSymbol(1), false);
11786 assert.strictEqual(_.isSymbol(/x/), false);
11787 assert.strictEqual(_.isSymbol('a'), false);
11794 assert.strictEqual(_.isSymbol(realm.symbol), true);
11816 return Ctor ? _.isTypedArray(new Ctor(new ArrayBuffer(8))) : false;
11828 return index ? _.isTypedArray(value) : _.isTypedArray();
11833 assert.strictEqual(_.isTypedArray(args), false);
11834 assert.strictEqual(_.isTypedArray([1, 2, 3]), false);
11835 assert.strictEqual(_.isTypedArray(true), false);
11836 assert.strictEqual(_.isTypedArray(new Date), false);
11837 assert.strictEqual(_.isTypedArray(new Error), false);
11838 assert.strictEqual(_.isTypedArray(_), false);
11839 assert.strictEqual(_.isTypedArray(slice), false);
11840 assert.strictEqual(_.isTypedArray({ 'a': 1 }), false);
11841 assert.strictEqual(_.isTypedArray(1), false);
11842 assert.strictEqual(_.isTypedArray(/x/), false);
11843 assert.strictEqual(_.isTypedArray('a'), false);
11844 assert.strictEqual(_.isTypedArray(symbol), false);
11859 return value ? _.isTypedArray(value) : false;
11878 assert.strictEqual(_.isUndefined(), true);
11879 assert.strictEqual(_.isUndefined(undefined), true);
11890 return index ? _.isUndefined(value) : _.isUndefined();
11895 assert.strictEqual(_.isUndefined(args), false);
11896 assert.strictEqual(_.isUndefined([1, 2, 3]), false);
11897 assert.strictEqual(_.isUndefined(true), false);
11898 assert.strictEqual(_.isUndefined(new Date), false);
11899 assert.strictEqual(_.isUndefined(new Error), false);
11900 assert.strictEqual(_.isUndefined(_), false);
11901 assert.strictEqual(_.isUndefined(slice), false);
11902 assert.strictEqual(_.isUndefined({ 'a': 1 }), false);
11903 assert.strictEqual(_.isUndefined(1), false);
11904 assert.strictEqual(_.isUndefined(/x/), false);
11905 assert.strictEqual(_.isUndefined('a'), false);
11908 assert.strictEqual(_.isUndefined(symbol), false);
11919 assert.strictEqual(_.isUndefined(realm.undefined), true);
11936 assert.strictEqual(_.isWeakMap(weakMap), true);
11949 return index ? _.isWeakMap(value) : _.isWeakMap();
11954 assert.strictEqual(_.isWeakMap(args), false);
11955 assert.strictEqual(_.isWeakMap([1, 2, 3]), false);
11956 assert.strictEqual(_.isWeakMap(true), false);
11957 assert.strictEqual(_.isWeakMap(new Date), false);
11958 assert.strictEqual(_.isWeakMap(new Error), false);
11959 assert.strictEqual(_.isWeakMap(_), false);
11960 assert.strictEqual(_.isWeakMap(slice), false);
11961 assert.strictEqual(_.isWeakMap({ 'a': 1 }), false);
11962 assert.strictEqual(_.isWeakMap(map), false);
11963 assert.strictEqual(_.isWeakMap(1), false);
11964 assert.strictEqual(_.isWeakMap(/x/), false);
11965 assert.strictEqual(_.isWeakMap('a'), false);
11966 assert.strictEqual(_.isWeakMap(symbol), false);
11976 return _.isWeakMap({ 'constructor': value });
11986 assert.strictEqual(_.isWeakMap(realm.weakMap), true);
12003 assert.strictEqual(_.isWeakSet(weakSet), true);
12016 return index ? _.isWeakSet(value) : _.isWeakSet();
12021 assert.strictEqual(_.isWeakSet(args), false);
12022 assert.strictEqual(_.isWeakSet([1, 2, 3]), false);
12023 assert.strictEqual(_.isWeakSet(true), false);
12024 assert.strictEqual(_.isWeakSet(new Date), false);
12025 assert.strictEqual(_.isWeakSet(new Error), false);
12026 assert.strictEqual(_.isWeakSet(_), false);
12027 assert.strictEqual(_.isWeakSet(slice), false);
12028 assert.strictEqual(_.isWeakSet({ 'a': 1 }), false);
12029 assert.strictEqual(_.isWeakSet(1), false);
12030 assert.strictEqual(_.isWeakSet(/x/), false);
12031 assert.strictEqual(_.isWeakSet('a'), false);
12032 assert.strictEqual(_.isWeakSet(set), false);
12033 assert.strictEqual(_.isWeakSet(symbol), false);
12040 assert.strictEqual(_.isWeakSet(realm.weakSet), true);
12067 … assert.strictEqual(_[methodName](object), false, '`_.' + methodName + '` returns `false`');
12088 _[methodName](xml);
12107 iteratee = _.iteratee(fn),
12118 … expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object]));
12121 var identity = index ? _.iteratee(value) : _.iteratee();
12131 var matches = _.iteratee({ 'a': 1, 'b': 2 });
12147 matches = _.iteratee(source);
12169 matches = _.iteratee([0, 'a']);
12173 matches = _.iteratee(['0', 'a']);
12176 matches = _.iteratee([1, undefined]);
12184 matches = _.iteratee(['a.b', { 'c': 1 }]);
12200 matches = _.iteratee(['a', source]);
12222 prop = _.iteratee(0);
12226 prop = _.iteratee('0');
12234 prop = _.iteratee('a.b');
12249 object = { 'a': 1 , 'iteratee': _.iteratee(_.partial(fn, 2)) };
12253 object.iteratee = _.iteratee(_.partialRight(fn, 3));
12260 var iteratee = _.iteratee;
12261 delete _.iteratee;
12263 assert.deepEqual(_.map([{ 'a': 1 }], 'a'), [1]);
12265 _.iteratee = iteratee;
12273 iteratees = lodashStable.map(array, _.iteratee),
12290 getPropA = _.partial(_.property, 'a'),
12291 getPropB = _.partial(_.property, 'b'),
12292 getLength = _.partial(_.property, 'length'),
12293 iteratee = _.iteratee;
12311 _.iteratee = getLength;
12312 assert.deepEqual(_.countBy(array), { '3': 2, '5': 1 });
12313 _.iteratee = iteratee;
12324 _.iteratee = getPropA;
12325 assert.deepEqual(_.differenceBy(objects, [objects[1]]), [objects[0]]);
12326 _.iteratee = iteratee;
12337 _.iteratee = getPropB;
12338 assert.deepEqual(_.dropRightWhile(objects), objects.slice(0, 2));
12339 _.iteratee = iteratee;
12350 _.iteratee = getPropB;
12351 assert.deepEqual(_.dropWhile(objects.reverse()).reverse(), objects.reverse().slice(0, 2));
12352 _.iteratee = iteratee;
12363 _.iteratee = getPropA;
12364 assert.strictEqual(_.every(objects.slice(1)), true);
12365 _.iteratee = iteratee;
12378 _.iteratee = getPropA;
12379 assert.deepEqual(_.filter(objects), [objects[1]]);
12380 _.iteratee = iteratee;
12391 _.iteratee = getPropA;
12392 assert.strictEqual(_.find(objects), objects[1]);
12393 _.iteratee = iteratee;
12404 _.iteratee = getPropA;
12405 assert.strictEqual(_.findIndex(objects), 1);
12406 _.iteratee = iteratee;
12417 _.iteratee = getPropA;
12418 assert.strictEqual(_.findLast(objects), objects[2]);
12419 _.iteratee = iteratee;
12430 _.iteratee = getPropA;
12431 assert.strictEqual(_.findLastIndex(objects), 2);
12432 _.iteratee = iteratee;
12443 _.iteratee = getPropB;
12444 assert.strictEqual(_.findKey(objects), '2');
12445 _.iteratee = iteratee;
12456 _.iteratee = getPropB;
12457 assert.strictEqual(_.findLastKey(objects), '2');
12458 _.iteratee = iteratee;
12469 _.iteratee = getLength;
12470 assert.deepEqual(_.groupBy(array), { '3': ['one', 'two'], '5': ['three'] });
12471 _.iteratee = iteratee;
12482 _.iteratee = getPropA;
12483 assert.deepEqual(_.intersectionBy(objects, [objects[2]]), [objects[1]]);
12484 _.iteratee = iteratee;
12495 _.iteratee = getLength;
12496 assert.deepEqual(_.keyBy(array), { '3': 'two', '5': 'three' });
12497 _.iteratee = iteratee;
12508 _.iteratee = getPropA;
12509 assert.deepEqual(_.map(objects), [0, 1, 1]);
12510 _.iteratee = iteratee;
12521 _.iteratee = getPropB;
12522 assert.deepEqual(_.mapKeys({ 'a': { 'b': 2 } }), { '2': { 'b': 2 } });
12523 _.iteratee = iteratee;
12534 _.iteratee = getPropB;
12535 assert.deepEqual(_.mapValues({ 'a': { 'b': 2 } }), { 'a': 2 });
12536 _.iteratee = iteratee;
12547 _.iteratee = getPropB;
12548 assert.deepEqual(_.maxBy(objects), objects[2]);
12549 _.iteratee = iteratee;
12560 _.iteratee = getPropA;
12561 assert.strictEqual(_.meanBy(objects), 2 / 3);
12562 _.iteratee = iteratee;
12573 _.iteratee = getPropB;
12574 assert.deepEqual(_.minBy(objects), objects[0]);
12575 _.iteratee = iteratee;
12588 _.iteratee = getPropA;
12589 assert.deepEqual(_.partition(objects), [objects.slice(0, 2), objects.slice(2)]);
12590 _.iteratee = iteratee;
12601 _.iteratee = getPropA;
12602 assert.deepEqual(_.pullAllBy(objects.slice(), [{ 'a': 1, 'b': 0 }]), [objects[0]]);
12603 _.iteratee = iteratee;
12614 _.iteratee = getSum;
12615 assert.strictEqual(_.reduce(objects, undefined, 0), 2);
12616 _.iteratee = iteratee;
12627 _.iteratee = getSum;
12628 assert.strictEqual(_.reduceRight(objects, undefined, 0), 2);
12629 _.iteratee = iteratee;
12642 _.iteratee = getPropA;
12643 assert.deepEqual(_.reject(objects), [objects[0]]);
12644 _.iteratee = iteratee;
12657 _.iteratee = getPropA;
12658 _.remove(objects);
12660 _.iteratee = iteratee;
12671 _.iteratee = getPropB;
12672 assert.strictEqual(_.some(objects), true);
12673 _.iteratee = iteratee;
12684 _.iteratee = getPropA;
12685 assert.deepEqual(_.sortBy(objects.slice().reverse()), [objects[0], objects[2], objects[1]]);
12686 _.iteratee = iteratee;
12699 _.iteratee = getPropA;
12700 assert.strictEqual(_.sortedIndexBy(objects, { 'a': 40 }), 1);
12701 _.iteratee = iteratee;
12714 _.iteratee = getPropA;
12715 assert.strictEqual(_.sortedLastIndexBy(objects, { 'a': 40 }), 1);
12716 _.iteratee = iteratee;
12727 _.iteratee = getPropB;
12728 assert.strictEqual(_.sumBy(objects), 1);
12729 _.iteratee = iteratee;
12740 _.iteratee = getPropB;
12741 assert.deepEqual(_.takeRightWhile(objects), objects.slice(2));
12742 _.iteratee = iteratee;
12753 _.iteratee = getPropB;
12754 assert.deepEqual(_.takeWhile(objects.reverse()), objects.reverse().slice(2));
12755 _.iteratee = iteratee;
12766 _.iteratee = function() {
12772 assert.deepEqual(_.transform(objects, undefined, { 'sum': 0 }), { 'sum': 2 });
12773 _.iteratee = iteratee;
12784 _.iteratee = getPropB;
12785 assert.deepEqual(_.uniqBy(objects), [objects[0], objects[2]]);
12786 _.iteratee = iteratee;
12797 _.iteratee = getPropB;
12798 assert.deepEqual(_.unionBy(objects.slice(0, 1), [objects[2]]), [objects[0], objects[2]]);
12799 _.iteratee = iteratee;
12810 _.iteratee = getPropA;
12811 assert.deepEqual(_.xorBy(objects, objects.slice(1)), [objects[0]]);
12812 _.iteratee = iteratee;
12830 assert.strictEqual(_.join(array, '~'), 'a~b~c');
12837 var wrapped = _(array);
12850 assert.ok(_(array).chain().join('~') instanceof _);
12873 var actual = _.keyBy(array, function(object) {
12888 return index ? _.keyBy(array, value) : _.keyBy(array);
12898 actual = _.keyBy(array, 'dir');
12906 var actual = _.keyBy([6.1, 4.2, 6.3], function(n) {
12923 assert.deepEqual(_.keyBy(array, 0), { '1': [1, 'a'], '2': [2, 'b'] });
12924 assert.deepEqual(_.keyBy(array, 1), { 'a': [2, 'a'], 'b': [2, 'b'] });
12930 var actual = _.keyBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor);
12943 var actual = _(array).keyBy().map(square).filter(isEven).take().value();
12945 assert.deepEqual(actual, _.take(_.filter(_.map(_.keyBy(array), square), isEven)));
12958 var func = _[methodName],
13162 assert.strictEqual(_.last(array), 4);
13171 assert.strictEqual(_.last([]), undefined);
13178 actual = lodashStable.map(array, _.last);
13187 assert.strictEqual(_(array).last(), 4);
13198 assert.ok(_(array).chain().last() instanceof _);
13209 var wrapped = _(array).chain().last();
13226 wrapped = _(array).filter(isEven);
13228 assert.strictEqual(wrapped.last(), _.last(_.filter(array, isEven)));
13245 assert.strictEqual(_.lowerCase('--Foo-Bar--'), 'foo bar');
13246 assert.strictEqual(_.lowerCase('fooBar'), 'foo bar');
13247 assert.strictEqual(_.lowerCase('__FOO_BAR__'), 'foo bar');
13259 assert.strictEqual(_.lowerFirst('fred'), 'fred');
13260 assert.strictEqual(_.lowerFirst('Fred'), 'fred');
13261 assert.strictEqual(_.lowerFirst('FRED'), 'fRED');
13273 assert.strictEqual(_.lt(1, 3), true);
13274 assert.strictEqual(_.lt('abc', 'def'), true);
13280 assert.strictEqual(_.lt(3, 1), false);
13281 assert.strictEqual(_.lt(3, 3), false);
13282 assert.strictEqual(_.lt('def', 'abc'), false);
13283 assert.strictEqual(_.lt('def', 'def'), false);
13295 assert.strictEqual(_.lte(1, 3), true);
13296 assert.strictEqual(_.lte(3, 3), true);
13297 assert.strictEqual(_.lte('abc', 'def'), true);
13298 assert.strictEqual(_.lte('def', 'def'), true);
13304 assert.strictEqual(_.lt(3, 1), false);
13305 assert.strictEqual(_.lt('def', 'abc'), false);
13315 func = _[methodName],
13392 var func = _[methodName],
13473 assert.deepEqual(_.map(array, String), expected);
13474 assert.deepEqual(_.map(object, String), expected);
13481 assert.deepEqual(_.map(objects, 'a'), ['x', 'y']);
13492 var actual = _.map(new Foo, identity);
13505 return index ? _.map(collection, value) : _.map(collection);
13519 return index ? _.map(collection) : _.map();
13529 assert.deepEqual(_.map(1), []);
13536 var actual = _.map(document.getElementsByTagName('body'), function(element) {
13553 assert.deepEqual(_.map(object, identity), [value]);
13560 assert.ok(_(array).map(noop) instanceof _);
13573 expected = [1, 0, _.map(array.slice(1), square)];
13575 _(array).slice(1).map(function(value, index, array) {
13582 _(array).slice(1).map(square).map(function(value, index, array) {
13589 _(array).slice(1).map(square).map(function(value, index) {
13596 _(array).slice(1).map(square).map(function(value) {
13603 _(array).slice(1).map(square).map(function() {
13626 var actual = _.mapKeys(object, String);
13633 var actual = _.mapKeys(array, String);
13640 var actual = _.mapKeys({ 'a': { 'b': 'c' } }, 'b');
13652 return index ? _.mapKeys(object, value) : _.mapKeys(object);
13670 var actual = _.mapValues(object, String);
13677 var actual = _.mapValues(array, String);
13684 var actual = _.mapValues({ 'a': { 'b': 2 } }, 'b');
13696 var result = index ? _.mapValues(object, value) : _.mapValues(object);
13709 var func = _[methodName],
13742 assert.ok(_(object)[methodName](noop) instanceof _);
13764 par = _.matches(source);
13791 return isMatches ? _.matches(source) : function(object) {
13792 return _.isMatch(object, source);
14130 matches = _.matchesProperty('a', 1);
14135 matches = _.matchesProperty('b', 3);
14138 matches = _.matchesProperty('a', { 'a': 1, 'c': 3 });
14141 matches = _.matchesProperty('a', { 'c': 3, 'd': 4 });
14145 matches = _.matchesProperty('a', { 'b': { 'c': 1 } });
14156 var matches = _.matchesProperty(path, 2);
14167 var matches = _.matchesProperty(path, 2);
14183 var matches = _.matchesProperty(key, values[index]),
14204 var matches = _.matchesProperty(index ? [path] : path, object[path]);
14218 var matches = _.matchesProperty(path, 1);
14230 var matches = _.matchesProperty(path, 1);
14249 var matches = _.matchesProperty(path, 1);
14267 var matches = _.matchesProperty(path, 1);
14281 var matches = _.matchesProperty(path, { 'b': 2 });
14298 assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14307 matches = _.matchesProperty('a', object1);
14316 var matches = _.matchesProperty('a', -0);
14319 matches = _.matchesProperty('a', 0);
14329 matches = _.matchesProperty('a', object1);
14345 actual = lodashStable.map(objects, _.matchesProperty('a', Foo));
14356 matches = _.matchesProperty('a', { 'b': 1 });
14365 actual = lodashStable.filter(objects, _.matchesProperty('a', ['d']));
14369 actual = lodashStable.filter(objects, _.matchesProperty('a', ['b', 'd']));
14372 actual = lodashStable.filter(objects, _.matchesProperty('a', ['d', 'b']));
14380 actual = lodashStable.filter(objects, _.matchesProperty('a', [2, 2]));
14393 …var actual = lodashStable.filter(objects, _.matchesProperty('a', [{ 'a': 1 }, { 'a': 4, 'b': 5 }])…
14407 var actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14412 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14417 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14437 var actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14442 actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14447 actual = lodashStable.filter(objects, _.matchesProperty('a', set));
14460 actual = lodashStable.map(objects, _.matchesProperty('b', undefined)),
14466 actual = lodashStable.map(objects, _.matchesProperty('a', { 'b': undefined }));
14477 var matches = _.matchesProperty(path, undefined);
14482 var matches = _.matchesProperty(path, undefined);
14494 var matches = _.matchesProperty('b', undefined);
14501 matches = _.matchesProperty('a', { 'c': undefined });
14514 matches = _.matchesProperty('a', { 'a': [], 'b': {} });
14528 matches = _.matchesProperty('a', source);
14555 assert.strictEqual(_.max([1, 2, 3]), 3);
14566 return index ? _.max(value) : _.max();
14576 assert.strictEqual(_.max(['a', 'b']), 'b');
14589 assert.strictEqual(_.mean(array), 5);
14596 actual = lodashStable.map(empties, _.mean);
14612 var actual = _.meanBy(objects, function(object) {
14624 _.meanBy(objects, function() {
14635 assert.strictEqual(_.meanBy(arrays, 0), 2);
14636 assert.strictEqual(_.meanBy(objects, 'a'), 2);
14686 var memoized = _.memoize(function(a, b, c) {
14698 memoized = _.memoize(fn, fn);
14708 memoized = _.memoize(fn, fn);
14721 assert.raises(function() { _.memoize(noop, true); }, TypeError);
14732 return _.isFunction(index ? _.memoize(noop, resolver) : _.memoize(noop));
14752 var memoized = _.memoize(identity);
14771 var memoized = _.memoize(function() {
14791 var oldCache = _.memoize.Cache;
14792 _.memoize.Cache = CustomCache;
14794 var memoized = _.memoize(function(object) {
14808 _.memoize.Cache = oldCache;
14814 var oldCache = _.memoize.Cache;
14815 _.memoize.Cache = ImmutableCache;
14817 var memoized = _.memoize(function(object) {
14831 _.memoize.Cache = oldCache;
14840 var func = _._memoizeCapped;
14897 assert.deepEqual(_.merge(names, ages, heights), expected);
14916 var actual = _.merge(object, source);
14926 actual = _.merge({ 'a': 1 }, { 'a': 2 }, { 'a': 3 }, expected);
14937 actual = _.merge(Foo, source);
14948 actual = _.merge({ 'prop': fn }, object);
14958 actual = _.merge({ 'prop': fn }, { 'prop': fn }, object);
14969 actual = _.merge({}, source1, source2);
14974 actual = _.merge(source1, source2);
14984 actual = _.merge(object, { 'a': 1 });
14996 var actual = _.merge([], array),
15011 actual = _.merge(object1, object2);
15014 assert.notOk(_.isArguments(actual.value));
15018 actual = _.merge(object2, object1);
15019 assert.notOk(_.isArguments(actual.value));
15024 actual = _.merge({}, object1);
15025 assert.notOk(_.isArguments(actual.value));
15048 return Ctor ? _.merge({ 'value': new Ctor(buffer) }, { 'value': [1] }) : false;
15065 return Ctor ? _.merge({ 'value': array }, { 'value': new Ctor(buffer) }) : false;
15075 var actual = _.merge({ 'a': 1 }, { 'a': null });
15088 var object = _.merge({}, { 'a': value, 'b': { 'c': value } });
15100 actual = _.merge({}, { 'value': buffer }).value;
15124 object = _.merge({}, { 'value': value }),
15144 actual = _.merge({}, source1, source2);
15152 actual = _.merge({}, source1, source2);
15167 actual = _.merge(new Foo, object);
15172 actual = _.merge([new Foo], [object]);
15180 var actual = _.merge({ 'a': 1 }, { 'a': undefined, 'b': undefined });
15190 var actual = _.merge([4, 5, 6], array),
15198 actual = _.merge([4, 5, 6], array);
15215 _.merge(object, object);
15223 actual = _.merge(object, { 'a': ['x'] });
15227 actual = _.merge({ 'a': {} }, { 'a': [] });
15235 actual = _.merge(object, { 'a': ['x', 'y', 'z'] });
15250 return _.merge(pair[0], pair[1]).el === pair[1].el;
15266 var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, noop);
15269 actual = _.mergeWith([], [undefined], identity);
15279 _.mergeWith({}, source1, source2, noop);
15286 var actual = _.mergeWith({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) {
15298 _.mergeWith({}, { 'z': 1, 'a': { 'b': 2 } }, function() {
15299 actual.push(_.last(arguments));
15303 _.each(actual, function(a) {
15314 var actual = _.mergeWith({ 'a': 0 }, { 'a': { 'b': ['c'] } }, function(a, b) {
15328 var actual = _.mergeWith(object, source, function(a, b) {
15347 var method = _.method(path);
15359 var method = _.method(path);
15367 var array = lodashStable.times(3, _.constant);
15370 var method = _.method(path);
15387 var method = _.method(index ? [path] : path);
15402 var method = _.method(path);
15413 var method = _.method(path);
15425 var method = _.method(path);
15442 var method = _.method(path);
15458 var method = _.method(path);
15473 var method = _.method(path, 1, 2, 3);
15484 var method = _.method(path);
15501 var methodOf = _.methodOf(object);
15513 var methodOf = _.methodOf(object);
15521 var array = lodashStable.times(3, _.constant);
15524 var methodOf = _.methodOf(array);
15541 var methodOf = _.methodOf(object);
15556 var methodOf = _.methodOf(new Foo);
15567 var methodOf = _.methodOf(object);
15580 var methodOf = index ? _.methodOf() : _.methodOf(value);
15596 var methodOf = index ? _.methodOf() : _.methodOf(value);
15608 methodOf = _.methodOf(object);
15624 var methodOf = _.methodOf(object, 1, 2, 3);
15635 methodOf = _.methodOf(object);
15651 assert.strictEqual(_.min([1, 2, 3]), 1);
15662 return index ? _.min(value) : _.min();
15672 assert.strictEqual(_.min(['a', 'b']), 'a');
15681 var func = _[methodName],
15704 var actual = _([40])[methodName]();
15715 func = _[methodName],
15772 if (_.has(value, '__wrapped__')) {
15794 _.mixin(source);
15796 assert.strictEqual(_.a(array), 'a');
15797 assert.strictEqual(_(array).a().value(), 'a');
15798 assert.notOk('b' in _);
15799 assert.notOk('b' in _.prototype);
15801 reset(_);
15812 _.mixin(source);
15813 _.a = stubB;
15815 assert.strictEqual(_.a(array), 'b');
15816 assert.strictEqual(_(array).a().value(), 'a');
15818 reset(_);
15828 var object = lodashStable.create(_);
15832 assert.notOk('a' in _);
15833 assert.notOk('a' in _.prototype);
15835 reset(_);
15842 _.mixin(object, source);
15849 _.mixin(Wrapper, source);
15864 assert.strictEqual(_.mixin(object, source), object);
15865 assert.strictEqual(_.mixin(Wrapper, source), Wrapper);
15866 assert.strictEqual(_.mixin(), _);
15878 assert.strictEqual(_.mixin(object, new Foo), object);
15885 … return (func === _ ? 'lodash' : 'given') + ' function should ' + (chain ? '' : 'not ') + 'chain';
15888 lodashStable.each([_, Wrapper], function(func) {
15891 if (func === _) {
15892 _.mixin(source, options);
15894 _.mixin(func, source, options);
15918 _.mixin({ 'a': noop }, {});
15919 assert.notOk('a' in _);
15920 reset(_);
15929 _.mixin({}, source, 1);
15938 _.mixin(source, 1);
15944 reset(_);
15950 lodashStable.each([_, Wrapper], function(func) {
15952 if (func === _) {
15953 var wrapped = _(source),
15956 assert.strictEqual(actual.value(), _);
15959 wrapped = _(func);
15975 _.mixin({ 'a': _.countBy, 'b': _.filter });
15978 actual = _(array).a().map(square).b(isEven).take().value();
15980 assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven)));
15982 reset(_);
15998 assert.strictEqual(_.multiply(6, 4), 24);
15999 assert.strictEqual(_.multiply(-6, 4), -24);
16000 assert.strictEqual(_.multiply(-6, -4), 24);
16006 assert.strictEqual(_.multiply('6', '4'), 24);
16007 assert.deepEqual(_.multiply('x', 'y'), NaN);
16026 var actual = _.orderBy(objects, 'a', 'desc');
16033 var actual = _.orderBy(objects, ['a', 'b'], ['desc', 'asc']);
16041 actual = _.orderBy(objects, ['a', 'b']);
16048 return _.orderBy(objects, ['a', 'b'], index ? ['desc', order] : ['desc']);
16057 var actual = _.orderBy(objects, ['a'], [Object('desc')]);
16074 var over = _.overArgs(fn, doubled, square);
16081 var over = _.overArgs(fn, undefined, null);
16088 var over = _.overArgs(fn, 'b', 'a');
16095 var over = _.overArgs(fn, { 'b': 1 }, { 'a': 1 });
16102 var over = _.overArgs(fn, [['b', 1], ['a', 1]]);
16109 var over = _.overArgs(fn, ['a', 1]);
16112 over = _.overArgs(fn, [['a', 1]]);
16119 var over = _.overArgs(fn, [doubled, square], String);
16126 var over = _.overArgs(fn, doubled, square);
16133 var over = _.overArgs(fn);
16140 var over = _.overArgs(fn, doubled, identity);
16149 over = _.overArgs(noop, transform, transform, transform);
16158 var over = _.overArgs(function(x) {
16177 var negate = _.negate(isEven);
16186 var negate = _.negate(isEven);
16197 negate = _.negate(function() { argCount = arguments.length; }),
16224 assert.strictEqual(_.noConflict(), oldDash);
16225 assert.notStrictEqual(root._, oldDash);
16226 root._ = oldDash;
16237 var object = root._ = {};
16238 assert.strictEqual(_.noConflict(), oldDash);
16239 assert.strictEqual(root._, object);
16240 root._ = oldDash;
16259 assert.strictEqual(context._, expected);
16279 actual = _.now();
16284 assert.ok(_.now() > actual);
16295 var actual = _.now();
16313 return _.nth(array, index);
16323 return _.nth(array, -n);
16336 return n ? _.nth(array, n) : _.nth(array);
16345 return _.nth(array, n);
16358 return _.nth(array, 1);
16374 return _.nth(array, n);
16392 var func = _.nthArg(index);
16403 var func = _.nthArg(-n);
16417 var func = n ? _.nthArg(n) : _.nthArg();
16427 var func = _.nthArg(n);
16437 var func = _.nthArg(1);
16448 var func = _.nthArg(n);
16468 assert.deepEqual(_.omit(object, 'a', 'c'), { 'b': 2, 'd': 4 });
16469 assert.deepEqual(_.omit(object, ['a', 'd'], 'c'), { 'b': 2 });
16475 assert.deepEqual(_.omit(nested, 'b.c'), { 'a': 1, 'b': { 'd': 3} });
16482 actual = _.omit(object, [['a.b']]);
16493 assert.deepEqual(_.omit(object, path), { 'a': { 'b': 2 } });
16500 assert.deepEqual(_.omit({ '0': 'a' }, 0), {});
16508 var actual = _.omit(value, 'valueOf');
16520 assert.deepEqual(_.omit('', 'b'), { 'a': 1 });
16529 assert.deepEqual(_.omit(object, args), { 'b': 2, 'd': 4 });
16537 _.omit(object, path);
16553 var actual = _.omitBy(object, function(n) {
16567 func = _[methodName],
16701 once = _.once(function() { return ++count; });
16713 var once = _.once(function() {
16725 var once = _.once(function() {
16744 var over = _.over(Math.max, Math.min);
16751 var over = _.over(undefined, null);
16758 var over = _.over('b', 'a');
16765 var over = _.over({ 'b': 1 }, { 'a': 1 });
16772 var over = _.over([['b', 2], ['a', 2]]);
16781 var over = _.over(['a', 1]);
16786 over = _.over([['a', 1]]);
16795 var over = _.over(function() {
16805 var over = _.over(function() { return this.b; }, function() { return this.a; }),
16820 var over = _.overEvery(stubTrue, stubOne, stubA);
16830 over = _.overEvery(countTrue, countFalse, countTrue);
16839 var over = _.overEvery(undefined, null);
16848 var over = _.overEvery('b', 'a');
16857 var over = _.overEvery({ 'b': 2 }, { 'a': 1 });
16866 var over = _.overEvery([['b', 2], ['a', 1]]);
16875 var over = _.overEvery(['a', 1]);
16881 over = _.overEvery([['a', 1]]);
16890 var over = _.overEvery(stubTrue, [stubFalse]);
16899 var over = _.overEvery(function() {
16910 var over = _.overEvery(function() { return this.b; }, function() { return this.a; }),
16928 var over = _.overSome(stubFalse, stubOne, stubString);
16931 over = _.overSome(stubNull, stubA, stubZero);
16941 over = _.overSome(countFalse, countTrue, countFalse);
16950 var over = _.overSome(stubFalse, stubFalse, stubFalse);
16953 over = _.overSome(stubNull, stubZero, stubString);
16960 var over = _.overSome(undefined, null);
16969 var over = _.overSome('b', 'a');
16978 var over = _.overSome({ 'b': 2 }, { 'a': 1 });
16987 var over = _.overSome([['b', 2], ['a', 1]]);
16996 var over = _.overSome(['a', 1]);
17002 over = _.overSome([['a', 1]]);
17011 var over = _.overSome(stubFalse, [stubTrue]);
17020 var over = _.overSome(function() {
17031 var over = _.overSome(function() { return this.b; }, function() { return this.a; }),
17055 return index ? _.pad(string, 6, value) : _.pad(string, 6);
17064 assert.strictEqual(_.pad(string, 8), ' abc ');
17065 assert.strictEqual(_.pad(string, 8, '_-'), '_-abc_-_');
17075 return _.pad(value, 6) === ' abc ';
17096 return index ? _.padEnd(string, 6, value) : _.padEnd(string, 6);
17105 assert.strictEqual(_.padEnd(string, 6, '_-'), 'abc_-_');
17115 return _.padEnd(value, 6) === 'abc ';
17136 return index ? _.padStart(string, 6, value) : _.padStart(string, 6);
17145 assert.strictEqual(_.padStart(string, 6, '_-'), '_-_abc');
17155 return _.padStart(value, 6) === ' abc';
17167 var func = _[methodName],
17214 return _.pad(string, 6, value);
17232 return _.parseInt('10', radix);
17241 assert.strictEqual(_.parseInt('10'), 10);
17242 assert.strictEqual(_.parseInt('10', 0), 10);
17243 assert.strictEqual(_.parseInt('10', 10), 10);
17244 assert.strictEqual(_.parseInt('10', undefined), 10);
17251 assert.strictEqual(_.parseInt(string), 32);
17252 assert.strictEqual(_.parseInt(string, 0), 32);
17253 assert.strictEqual(_.parseInt(string, 16), 32);
17254 assert.strictEqual(_.parseInt(string, undefined), 32);
17261 assert.strictEqual(_.parseInt('08'), 8);
17262 assert.strictEqual(_.parseInt('08', 10), 8);
17272 func = (index ? (lodashBizarro || {}) : _).parseInt;
17302 assert.strictEqual(_.parseInt('08', object), 8);
17303 assert.strictEqual(_.parseInt('0x20', object), 32);
17310 actual = lodashStable.map(strings, _.parseInt);
17314 actual = lodashStable.map('123', _.parseInt);
17324 var func = _[methodName],
17383 var _ph = _.placeholder = {},
17389 delete _.placeholder;
17439 curried = _.curry(func(fn, 1), 2);
17449 curried = _.curry(fn),
17468 var defaultsDeep = _.partialRight(_.mergeWith, function deep(value, other) {
17469 return lodashStable.isObject(value) ? _.mergeWith(value, other, deep) : value;
17485 var ph1 = _.bind.placeholder,
17486 ph2 = _.bindKey.placeholder,
17487 ph3 = _.partial.placeholder,
17488 ph4 = _.partialRight.placeholder;
17493 var a = _.partial(fn),
17494 b = _.partialRight(a, 3),
17495 c = _.partial(b, 1);
17512 var a = _.bindKey(object, 'fn'),
17513 b = _.partialRight(a, 4),
17514 c = _.partial(b, 2);
17518 a = _.bind(fn, object);
17519 b = _.partialRight(a, 4);
17520 c = _.partial(b, 2);
17524 a = _.partial(fn, 2);
17525 b = _.bind(a, object);
17526 c = _.partialRight(b, 4);
17538 var combo = _.partial(_.partialRight(Foo, 3), 1),
17551 var a = _.bindKey(object, 'fn', ph2, 2),
17552 b = _.partialRight(a, ph4, 6),
17553 c = _.partial(b, 1, ph3, 4);
17557 a = _.bind(fn, object, ph1, 2);
17558 b = _.partialRight(a, ph4, 6);
17559 c = _.partial(b, 1, ph3, 4);
17563 a = _.partial(fn, ph3, 2);
17564 b = _.bind(a, object, 1, ph1, 4);
17565 c = _.partialRight(b, ph4, 6);
17576 var a = _.bindKey(object, 'fn', ph2, 2),
17577 b = _.partialRight(a, ph4, 4),
17578 c = _.partial(b, ph3, 3);
17582 a = _.bind(fn, object, ph1, 2);
17583 b = _.partialRight(a, ph4, 4);
17584 c = _.partial(b, ph3, 3);
17588 a = _.partial(fn, ph3, 2);
17589 b = _.bind(a, object, ph1, 3);
17590 c = _.partialRight(b, ph4, 4);
17602 var a = _.bind(fn, { 'a': 1 }),
17603 b = _.bind(a, { 'a': 2 }),
17604 c = _.bind(b, { 'a': 3 });
17620 bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object),
17623 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17624 var bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1);
17630 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17631 var bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object),
17632 bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1);
17642 curried = _[methodName](fn),
17645 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17651 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17652 var curried = _[methodName](fn);
17660 var func = _[methodName],
17665 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17672 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17694 assert.deepEqual(_.partition([], identity), [[], []]);
17695 assert.deepEqual(_.partition(array, stubTrue), [array, []]);
17696 assert.deepEqual(_.partition(array, stubFalse), [[], array]);
17706 return index ? _.partition(array, value) : _.partition(array);
17716 actual = _.partition(objects, 'a');
17730 assert.deepEqual(_.partition(array, 0), [[array[0], array[2]], [array[1]]]);
17731 assert.deepEqual(_.partition(array, 1), [[array[1]], [array[0], array[2]]]);
17737 var actual = _.partition({ 'a': 1.1, 'b': 0.2, 'c': 1.3 }, Math.floor);
17754 assert.deepEqual(_.pick(object, 'a', 'c'), { 'a': 1, 'c': 3 });
17755 assert.deepEqual(_.pick(object, ['a', 'd'], 'c'), { 'a': 1, 'c': 3, 'd': 4 });
17761 assert.deepEqual(_.pick(nested, 'b.c'), { 'b': { 'c': 2 } });
17768 actual = _.pick(object, [['a.b']]);
17779 assert.deepEqual(_.pick(object, path), { 'a.b': 1 });
17786 assert.deepEqual(_.pick({ '0': 'a', '1': 'b' }, 0), { '0': 'a' });
17793 assert.deepEqual(_.pick(value, 'valueOf'), {});
17800 assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice });
17806 assert.deepEqual(_.pick(object, args), { 'a': 1, 'c': 3 });
17820 var actual = _.pickBy(object, function(n) {
17831 actual = _.pickBy(object, stubTrue);
17843 func = _[methodName],
17945 var prop = _.property(path);
17957 var prop = _.property(path);
17969 var prop = _.property(path);
17980 var prop = _.property(path);
17992 var prop = _.property(key);
18011 var prop = _.property(index ? [path] : path);
18025 var prop = _.property(path);
18037 var prop = _.property(path);
18054 var prop = _.property(path);
18070 var prop = _.property(path);
18085 propOf = _.propertyOf(object);
18097 propOf = _.propertyOf(object);
18112 var propOf = _.propertyOf(new Foo);
18123 propOf = _.propertyOf(array);
18137 var propOf = _.propertyOf(object);
18156 var propOf = _.propertyOf(object);
18168 propOf = _.propertyOf(object);
18183 var propOf = index ? _.propertyOf(value) : _.propertyOf();
18199 var propOf = index ? _.propertyOf(value) : _.propertyOf();
18210 var propOf = _.propertyOf({});
18227 actual = _.pullAll(array, array);
18243 var actual = _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], function(object) {
18256 _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], function() {
18274 actual = _.pullAllWith(objects, [{ 'x': 2, 'y': 2 }], lodashStable.isEqual);
18285 var func = _[methodName],
18345 actual = _.pullAt(array, [0, 1]);
18355 actual = _.pullAt(array, [1, 3, 11, 7, 5, 9]);
18365 actual = _.pullAt(array, [0, 2, 0, 1, 0, 2]);
18375 actual = _.pullAt(array, [2, 4, 0]);
18385 assert.deepEqual(_.pullAt(array, 2, 0), ['c', 'a']);
18389 assert.deepEqual(_.pullAt(array, [3, 0], 2), ['d', 'a', 'c']);
18397 actual = _.pullAt(array);
18402 actual = _.pullAt(array, [], []);
18420 actual = _.pullAt(array, values);
18438 return _.pullAt(array, key);
18450 var actual = _.pullAt(array, 'a.b');
18456 actual = _.pullAt(array, 'a.b.c');
18470 return _.pullAt(array, 0, 1, 'pop', 'push');
18489 return _.random();
18502 var result = _.random(min, max);
18514 var result = _.random(max);
18527 return _.random(min, max);
18540 var result = _.random(min, max);
18545 return _.random(MAX_INTEGER);
18553 _.random(NaN, NaN),
18554 _.random('1', '1'),
18555 _.random(Infinity, Infinity)
18566 actual = _.random(min, max);
18575 var actual = _.random(true);
18578 actual = _.random(2, true);
18581 actual = _.random(2, 4, true);
18590 randoms = lodashStable.map(array, _.random);
18605 var func = _[methodName],
18713 var rearged = _.rearg(fn, [2, 0, 1]);
18720 var rearged = _.rearg(fn, [1, 1, 1]);
18727 var rearged = _.rearg(fn, [1, 4]);
18741 var rearged = _.rearg(fn, [value]);
18751 var rearged = _.rearg(fn);
18754 rearged = _.rearg(fn, [], []);
18761 var rearged = _.rearg(fn, 2, 0, 1);
18768 var rearged = _.rearg(fn, [2], [0, 1]);
18775 var rearged = _.rearg(fn, [1, 0]);
18782 var rearged1 = _.rearg(fn, 2, 1, 0),
18783 rearged2 = _.rearg(rearged1, 1, 0, 2);
18799 assert.strictEqual(_.reduce(array), 1);
18807 _.reduce(array, function() {
18814 _.reduce(array, function() {
18826 firstKey = _.head(_.keys(object));
18832 _.reduce(object, function() {
18843 _.reduce(object, function() {
18861 assert.strictEqual(_.reduceRight(array), 3);
18869 _.reduceRight(array, function() {
18876 _.reduceRight(array, function() {
18894 _.reduceRight(object, function() {
18905 _.reduceRight(object, function() {
18918 var func = _[methodName],
18988 assert.strictEqual(_(array)[methodName](add), 6);
18999 assert.ok(_(array).chain()[methodName](add) instanceof _);
19017 assert.deepEqual(_.reject(array, isEven), [1, 3]);
19027 func = _[methodName],
19058 var wrapped = _(array);
19088 var actual = _(array).slice(1).map(square)[methodName](predicate).value();
19089 … assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
19091 actual = _(object).mapValues(square)[methodName](predicate).value();
19092 assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
19107 _(array).slice(1)[methodName](function(value, index, array) {
19114 _(array).slice(1).map(square)[methodName](function(value, index, array) {
19121 _(array).slice(1).map(square)[methodName](function(value, index) {
19128 _(array).slice(1).map(square)[methodName](function(value) {
19135 _(array).slice(1).map(square)[methodName](function() {
19156 actual = _.remove(array, isEven);
19169 _.remove(array, function(n, index) {
19183 _.remove(objects, { 'a': 1 });
19191 _.remove(objects, ['a', 1]);
19199 _.remove(objects, 'a');
19210 _.remove(array, function(n) {
19224 _.remove(array, function(n) {
19236 _.remove(array, function(n, index) {
19254 assert.strictEqual(_.repeat('*', 3), '***');
19255 assert.strictEqual(_.repeat(string, 2), 'abcabc');
19266 return index ? _.repeat(string, n) : _.repeat(string);
19275 assert.strictEqual(_.repeat(string, 0), '');
19276 assert.strictEqual(_.repeat(string, -2), '');
19282 assert.strictEqual(_.repeat(string, '2'), 'abcabc');
19283 assert.strictEqual(_.repeat(string, 2.6), 'abcabc');
19284 assert.strictEqual(_.repeat('*', { 'valueOf': stubThree }), '***');
19290 assert.strictEqual(_.repeat(Object(string), 2), 'abcabc');
19291 assert.strictEqual(_.repeat({ 'toString': lodashStable.constant('*') }, 3), '***');
19297 var actual = lodashStable.map(['a', 'b', 'c'], _.repeat);
19311 assert.strictEqual(_.replace(string, 'de', '123'), 'abc123');
19312 assert.strictEqual(_.replace(string, /[bd]/g, '-'), 'a-c-e');
19326 assert.strictEqual(_.result(object, 'b'), 'b');
19332 var actual = _.result(object, 'c', object.b);
19342 assert.strictEqual(_.result(value, path), 'b');
19352 assert.strictEqual(_.result(value, path), 1);
19362 var func = _[methodName];
19551 var rest = _.rest(fn);
19558 var rest = _.rest(fn, 1);
19569 var rest = _.rest(fn, value);
19579 var rest = _.rest(fn, 1.6);
19586 var rest = _.rest(fn);
19593 var rest = _.rest(function(a, b, c, d) {
19613 actual = _.reverse(array);
19626 wrapped = _(array).reverse(),
19629 assert.ok(wrapped instanceof _);
19646 actual = _(array).slice(1).reverse().value();
19671 var wrapped = _(array).slice(1).map(String).reverse(),
19675 assert.ok(wrapped instanceof _);
19694 actual = _(array)[methodName](identity).thru(_.compact).reverse().value();
19699 … actual = _(array).thru(_.compact)[methodName](identity).pull(1).push(3).reverse().value();
19717 wrapped = _(array).chain().reverse().head();
19719 assert.ok(wrapped instanceof _);
19720 assert.strictEqual(wrapped.value(), _.head(expected));
19735 var func = _[methodName],
19815 _.round(10.0000001, 1000),
19816 _.round(MAX_SAFE_INTEGER, 293)
19901 var lodash = _.runInContext({
19918 lodashStable.times(2, _.uniqueId);
19920 var oldId = Number(_.uniqueId()),
19921 lodash = _.runInContext();
19923 assert.ok(_.uniqueId() > oldId);
19945 var actual = _.sample(array);
19956 result.push(_.sample(value));
19967 actual = _.sample(object);
19983 var actual = _.sampleSize(array, 2);
19992 var actual = _.sampleSize(array, array.length).sort();
20005 return index ? _.sampleSize(['a'], size) : _.sampleSize(['a']);
20015 assert.deepEqual(_.sampleSize(array, n), []);
20023 var actual = _.sampleSize(array, n).sort();
20031 var actual = _.sampleSize(array, 1.6);
20042 result.push(_.sampleSize(value, 1));
20053 actual = _.sampleSize(object, 2);
20062 var actual = lodashStable.map([['a']], _.sampleSize);
20075 var actual = _.setWith({ '0': {} }, '[0][1][2]', 3, function(value) {
20085 var actual = _.setWith({}, 'a[0].b.c', 4, noop);
20095 var func = _[methodName],
20136 assert.strictEqual(_.unset(object, symbol), true);
20302 assert.notStrictEqual(_.shuffle(array), array);
20308 assert.deepEqual(_.shuffle(array).sort(), array);
20309 assert.deepEqual(_.shuffle(object).sort(), array);
20316 return _.shuffle([1, 2]);
20325 assert.deepEqual(_.shuffle(1), []);
20339 assert.strictEqual(_.size({ 'one': 1, 'two': 2, 'three': 3 }), 3);
20345 assert.strictEqual(_.size(array), 3);
20355 return index ? _.size(object) : _.size();
20365 assert.strictEqual(_.size(args), 3);
20376 assert.strictEqual(_.size(new Foo(array)), 3);
20386 assert.strictEqual(_.size(map), 2);
20402 assert.strictEqual(_.size(set), 2);
20414 assert.strictEqual(_.size({ 'length': -1 }), 1);
20420 assert.strictEqual(_.size({ 'length': MAX_SAFE_INTEGER + 1 }), 1);
20426 assert.strictEqual(_.size({ 'length': '0' }), 1);
20440 var actual = _.slice(array);
20448 assert.deepEqual(_.slice(array, 1), [2, 3]);
20449 assert.deepEqual(_.slice(array, 1, 3), [2, 3]);
20456 assert.deepEqual(_.slice(array, start), []);
20466 return _.slice(array, start);
20475 assert.deepEqual(_.slice(array, -1), [3]);
20482 assert.deepEqual(_.slice(array, start), array);
20490 assert.deepEqual(_.slice(array, start, 2), []);
20497 assert.deepEqual(_.slice(array, 0, 1), [1]);
20504 assert.deepEqual(_.slice(array, 0, end), array);
20516 return index ? _.slice(array, 0, end) : _.slice(array, 0);
20525 assert.deepEqual(_.slice(array, 0, -1), [1, 2]);
20532 assert.deepEqual(_.slice(array, 0, end), []);
20542 return _.slice.apply(_, [array].concat(pos));
20552 actual = lodashStable.map(array, _.slice);
20564 wrapped = _(array);
20606 assert.strictEqual(_.some([false, 1, ''], identity), true);
20607 assert.strictEqual(_.some([null, 'a', 0], identity), true);
20617 return _.some(value, identity);
20629 assert.strictEqual(_.some([null, true, null], function(value) {
20640 assert.strictEqual(_.some([false, false, false], identity), false);
20641 assert.strictEqual(_.some([null, 0, ''], identity), false);
20652 return index ? _.some(array, value) : _.some(array);
20660 return index ? _.some(array, value) : _.some(array);
20670 assert.strictEqual(_.some(objects, 'a'), false);
20671 assert.strictEqual(_.some(objects, 'b'), true);
20678 assert.strictEqual(_.some(objects, { 'a': 0 }), true);
20679 assert.strictEqual(_.some(objects, { 'b': 2 }), false);
20685 var actual = lodashStable.map([[1]], _.some);
20705 var actual = lodashStable.map(_.sortBy(objects, function(object) {
20720 return index ? _.sortBy(array, value) : _.sortBy(array);
20729 var actual = lodashStable.map(_.sortBy(objects.concat(undefined), 'b'), 'b');
20736 var actual = _.sortBy({ 'a': 1, 'b': 2, 'c': 3 }, Math.sin);
20748 assert.deepEqual(_.sortBy(array), expected);
20753 assert.deepEqual(_.sortBy(array), expected);
20759 assert.deepEqual(_.sortBy(1), []);
20765 var actual = _.sortBy(objects, function(object) {
20777 var actual = lodashStable.map([[2, 1, 3], [3, 2, 1]], _.sortBy);
20787 var func = _[methodName];
20883 var func = _[methodName],
20939 assert.deepEqual(_.sortBy(array), expected);
20977 var func = _[methodName],
21034 var func = _[methodName],
21056 assert.deepEqual(_.sortedUniq(array), expected);
21070 assert.deepEqual(_.split(string, 'c'), ['ab', 'de']);
21071 assert.deepEqual(_.split(string, /[bd]/), ['a', 'c', 'e']);
21072 assert.deepEqual(_.split(string, '', 2), ['a', 'b']);
21082 return index ? _.split(value) : _.split();
21092 actual = lodashStable.map(strings, _.split);
21101 var wrapped = _('abc');
21122 var spread = _.spread(fn),
21132 var spread = _.spread(stubTrue),
21147 var spread = _.spread(fn, 1),
21161 var spread = _.spread(fn, value);
21171 var spread = _.spread(fn, 1.6),
21187 assert.strictEqual(_.startCase('--foo-bar--'), 'Foo Bar');
21188 assert.strictEqual(_.startCase('fooBar'), 'Foo Bar');
21189 assert.strictEqual(_.startCase('__FOO_BAR__'), 'FOO BAR');
21203 assert.strictEqual(_.startsWith(string, 'a'), true);
21209 assert.strictEqual(_.startsWith(string, 'b'), false);
21215 assert.strictEqual(_.startsWith(string, 'b', 1), true);
21222 assert.strictEqual(_.startsWith(string, 'a', position), false);
21232 return _.startsWith(string, 'a', position);
21242 assert.strictEqual(_.startsWith(string, 'a', position), true);
21243 assert.strictEqual(_.startsWith(string, 'b', position), false);
21250 assert.strictEqual(_.startsWith(string, 'bc', 1.2), true);
21259 var func = _[methodName],
21304 var func = _[methodName];
21340 assert.strictEqual(_.subtract(6, 4), 2);
21341 assert.strictEqual(_.subtract(-6, 4), -10);
21342 assert.strictEqual(_.subtract(-6, -4), -2);
21348 assert.strictEqual(_.subtract('6', '4'), 2);
21349 assert.deepEqual(_.subtract('x', 'y'), NaN);
21358 var func = _[methodName],
21414 var actual = _(1)[methodName](2);
21415 assert.notOk(actual instanceof _);
21426 var actual = _(1).chain()[methodName](2);
21427 assert.ok(actual instanceof _);
21446 var actual = _.sumBy(objects, function(object) {
21458 _.sumBy(array, function() {
21469 assert.strictEqual(_.sumBy(arrays, 0), 6);
21470 assert.strictEqual(_.sumBy(objects, 'a'), 6);
21480 func = _[methodName];
21533 return index ? _.tail(array) : _.tail();
21543 assert.deepEqual(_.tail(array), [2, 3]);
21549 assert.deepEqual(_.tail([]), []);
21556 actual = lodashStable.map(array, _.tail);
21568 var actual = _(array).tail().filter(function(value) {
21579 actual = _(array).filter(function(value) {
21586 assert.deepEqual(actual, _.tail(_.filter(array, isEven)));
21601 actual = _(array).slice(0, 1).tail().map(iteratee).value();
21607 actual = _(array).filter().slice(0, 1).tail().map(iteratee).value();
21628 assert.deepEqual(_.take(array, 2), [1, 2]);
21639 return _.take(array, n);
21649 assert.deepEqual(_.take(array, n), []);
21657 assert.deepEqual(_.take(array, n), array);
21665 actual = lodashStable.map(array, _.take);
21677 actual = _(array).take(2).take().value();
21679 assert.deepEqual(actual, _.take(_.take(array, 2)));
21681 actual = _(array).filter(predicate).take(2).take().value();
21683 assert.deepEqual(actual, _.take(_.take(_.filter(array, predicate), 2)));
21685 actual = _(array).take(6).takeRight(4).take(2).takeRight().value();
21686 assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(array, 6), 4), 2)));
21690 …actual = _(array).take(array.length - 1).filter(predicate).take(6).takeRight(4).take(2).takeRight(…
21692 …assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(_.filter(_.take(array, array.length…
21710 assert.deepEqual(_.takeRight(array, 2), [2, 3]);
21721 return _.takeRight(array, n);
21731 assert.deepEqual(_.takeRight(array, n), []);
21739 assert.deepEqual(_.takeRight(array, n), array);
21747 actual = lodashStable.map(array, _.takeRight);
21759 actual = _(array).takeRight(2).takeRight().value();
21761 assert.deepEqual(actual, _.takeRight(_.takeRight(array)));
21763 actual = _(array).filter(predicate).takeRight(2).takeRight().value();
21765 assert.deepEqual(actual, _.takeRight(_.takeRight(_.filter(array, predicate), 2)));
21767 actual = _(array).takeRight(6).take(4).takeRight(2).take().value();
21768 assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(array, 6), 4), 2)));
21772 actual = _(array).filter(predicate).takeRight(6).take(4).takeRight(2).take().value();
21774 …assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(_.filter(array, predicate), 6), 4),…
21798 var actual = _.takeRightWhile(array, function(n) {
21810 _.takeRightWhile(array, function() {
21820 assert.deepEqual(_.takeRightWhile(objects, { 'b': 2 }), objects.slice(2));
21826 assert.deepEqual(_.takeRightWhile(objects, ['b', 2]), objects.slice(2));
21832 assert.deepEqual(_.takeRightWhile(objects, 'b'), objects.slice(1));
21841 expected = _.takeRightWhile(array, predicate),
21842 wrapped = _(array).takeRightWhile(predicate);
21846 assert.strictEqual(wrapped.last(), _.last(expected));
21866 _(array).slice(1).takeRightWhile(function(value, index, array) {
21872 _(array).slice(1).map(square).takeRightWhile(function(value, index, array) {
21878 _(array).slice(1).map(square).takeRightWhile(function(value, index) {
21884 _(array).slice(1).map(square).takeRightWhile(function(index) {
21890 _(array).slice(1).map(square).takeRightWhile(function() {
21918 var actual = _.takeWhile(array, function(n) {
21930 _.takeWhile(array, function() {
21940 assert.deepEqual(_.takeWhile(objects, { 'b': 2 }), objects.slice(0, 1));
21946 assert.deepEqual(_.takeWhile(objects, ['b', 2]), objects.slice(0, 1));
21951 assert.deepEqual(_.takeWhile(objects, 'b'), objects.slice(0, 2));
21960 expected = _.takeWhile(array, predicate),
21961 wrapped = _(array).takeWhile(predicate);
21965 assert.strictEqual(wrapped.last(), _.last(expected));
21978 var actual = _(array)
21999 _(array).slice(1).takeWhile(function(value, index, array) {
22005 _(array).slice(1).map(square).takeWhile(function(value, index, array) {
22011 _(array).slice(1).map(square).takeWhile(function(value, index) {
22017 _(array).slice(1).map(square).takeWhile(function(value) {
22023 _(array).slice(1).map(square).takeWhile(function() {
22047 var actual = _.tap(array, function(value) {
22066 var wrapped = _(array).tap(function(value) {
22071 assert.ok(wrapped instanceof _);
22095 return _.template(string)(data);
22104 var compiled = _.template('<%= typeof __e %>');
22111 var compiled = _.template(
22127 …var compiled = _.template('<% // A code comment. %><% if (value) { %>yap<% } else { %>nope<% } %>'…
22136 var compiled = _.template('<% var b = a; %><%= b.value %>'),
22150 return _.template(string)(data);
22159 var compiled = _.template('<%= a ? "a=\\"A\\"" : "" %>'),
22168 var compiled = _.template('<%= value ? value : "b" %>'),
22177 var compiled = _.template('<%= typeof Math.abs %>');
22214 var compiled = _.template(key),
22225 assert.strictEqual(_.template('1${value}3')(data), '123');
22226 assert.strictEqual(_.template('${"{" + value + "\\}"}')(data), '{2}');
22232 var compiled = _.template('<%= a %>', { 'imports': { 'a': 1 } });
22239 var compiled = _.template(
22258 var settingsClone = lodashStable.clone(_.templateSettings);
22260 var settings = lodashStable.assign(index ? _.templateSettings : {}, {
22267 …compiled = _.template('<ul>{{ _.each(collection, function(value, index) {}}<li>{{= index }}: {{- v…
22271 lodashStable.assign(_.templateSettings, settingsClone);
22279 var settingsClone = lodashStable.clone(_.templateSettings);
22281 var settings = lodashStable.assign(index ? _.templateSettings : {}, {
22288 …compiled = _.template('<ul><? _.each(collection, function(value, index) { ?><li><?= index ?>: <?- …
22292 lodashStable.assign(_.templateSettings, settingsClone);
22299 …var compiled = _.template('<%= index %><%= collection[index] %><% _.each(collection, function(valu…
22308 var lodash = _.templateSettings.imports._,
22315 var compiled = _.template('{{= a }}');
22328 var lodash = _.templateSettings.imports._,
22329 delimiter = _.templateSettings.interpolate;
22331 _.templateSettings.imports._ = { 'escape': lodashStable.escape }; class in _.templateSettings.imports
22332 _.templateSettings.interpolate = /\{\{=([\s\S]+?)\}\}/g;
22334 var compiled = _.template('{{= a }}');
22337 _.templateSettings.imports._ = lodash;
22338 _.templateSettings.interpolate = delimiter;
22360 compiled = _.template(value + ' <%- a %> <% print(a) %> <%= a %>', settings),
22371 assert.strictEqual(_.template(expected)({}), expected);
22377 var compiled = _.template('a<%= this.String("b") %>c');
22381 object.compiled = _.template('A<%= this.b %>C', { 'variable': 'obj' });
22388 var compiled = _.template('<%= a %> \\b'),
22397 var compiled = _.template('<% print("\'\\n\\r\\t\\u2028\\u2029\\\\") %>');
22401 compiled = _.template('\'\n\r\t<%= a %>\u2028\u2029\\"');
22408 var compiled = _.template('\u2028<%= "\\u2028\\u2029" %>\u2029');
22415 var compiled = _.template("<%\
22428 var compiled = _.template('<%\n\
22440 var compiled = _.template('<span class="icon-<%= type %>2"></span>'),
22450 compiled = _.template('<%= func("a") %><%- func("b") %><% func("c") %>'),
22460 var compiled = _.template('<<\n a \n>>', { 'evaluate': /<<(.*?)>>/g });
22467 var compiled = _.template('<%= a %><%- a %>'),
22476 compiled = _.template('<%= a.b %><%- a.b %>');
22488 var compiled = index ? _.template(value) : _.template();
22499 compiled = _.template(expected, { 'evaluate': /<<(.+?)>>/g }),
22508 var compiled = _.template('<%= a %><% a = _.template(c)(obj) %><%= a %>'),
22520 assert.strictEqual(_.template(object)(data), '1');
22527 _.template('', options);
22536 assert.notOk('a' in _.templateSettings);
22537 _.template('', {}, data);
22538 assert.notOk('a' in _.templateSettings);
22540 delete _.templateSettings.a;
22546 _.template('')(1);
22549 _.template('', 1)(1);
22556 var compiled = _.template('x'),
22571 _.template('<% if x %>');
22582 compiled = _.template('x', options),
22586 _.template('<% if x %>', options);
22603 compiles = lodashStable.map(array, _.template),
22624 assert.strictEqual(_.truncate(string), 'hi-diddly-ho there, neighbo...');
22630 assert.strictEqual(_.truncate(string, { 'length': string.length }), string);
22631 assert.strictEqual(_.truncate(string, { 'length': string.length + 2 }), string);
22637 assert.strictEqual(_.truncate(string, { 'length': 24 }), 'hi-diddly-ho there, n...');
22643 …assert.strictEqual(_.truncate(string, { 'omission': ' [...]' }), 'hi-diddly-ho there, neig [...]');
22649 … assert.strictEqual(_.truncate(string, { 'omission': null }), 'hi-diddly-ho there, neighbnull');
22650 …assert.strictEqual(_.truncate(string, { 'omission': undefined }), 'hi-diddly-ho there, nundefined'…
22656 assert.strictEqual(_.truncate(string, { 'length': 4 }), 'h...');
22662 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': ' ' }), 'hi-diddly-ho there,...…
22663 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/ }), 'hi-diddly-ho there.…
22664 …assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/g }), 'hi-diddly-ho there…
22671 assert.strictEqual(_.truncate(string, { 'length': length }), '...');
22680 …assert.strictEqual(_.truncate(string, { 'length': { 'valueOf': lodashStable.constant(length) } }),…
22687 assert.strictEqual(_.truncate(Object(string), { 'length': 4 }), 'h...');
22688 …assert.strictEqual(_.truncate({ 'toString': lodashStable.constant(string) }, { 'length': 5 }), 'hi…
22694 var actual = lodashStable.map([string, string, string], _.truncate),
22712 throttled = _.throttle(function() { callCount++; }, 32);
22732 var throttled = _.throttle(identity, 32),
22757 var lodash = _.runInContext({
22787 throttled = _.throttle(function() { callCount++; }, 32);
22807 throttled = _.throttle(function() { callCount++; }, 32, options);
22828 var throttled = _.throttle(function() {
22855 throttled = _.throttle(function() { callCount++; }, 32, {});
22870 var withLeading = _.throttle(identity, 32, { 'leading': true });
22873 var withoutLeading = _.throttle(identity, 32, { 'leading': false });
22885 var withTrailing = _.throttle(function(value) {
22890 var withoutTrailing = _.throttle(function(value) {
22915 var throttled = _.throttle(function() {
22942 var lodash = _.runInContext({
22976 var func = _[methodName],
23062 var lodash = _.runInContext({
23180 assert.deepEqual(_.times(n), []);
23187 var actual = _.times(2.6, _.identity);
23196 _.times(1, function(assert) {
23210 return index ? _.times(3, value) : _.times(3);
23219 assert.deepEqual(_.times(3, doubled), [0, 2, 4]);
23229 return index ? _.times(value) : _.times();
23239 assert.deepEqual(_(3).times(), [0, 1, 2]);
23250 assert.ok(_(3).chain().times() instanceof _);
23266 assert.deepEqual(_.toArray({ 'a': 1, 'b': 2 }), [1, 2]);
23276 assert.deepEqual(_.toArray(object), ['a']);
23290 assert.deepEqual(_.toArray(map), [['a', 1], ['b', 2]]);
23300 assert.deepEqual(_.toArray(''), []);
23301 assert.deepEqual(_.toArray('ab'), ['a', 'b']);
23302 assert.deepEqual(_.toArray(Object('ab')), ['a', 'b']);
23315 var actual = _(array).slice(1).map(String).toArray().value();
23318 actual = _(object).toArray().slice(1).map(String).value();
23319 assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String));
23335 assert.deepEqual(_.toLower('--Foo-Bar--'), '--foo-bar--');
23336 assert.deepEqual(_.toLower('fooBar'), 'foobar');
23337 assert.deepEqual(_.toLower('__FOO_BAR__'), '__foo_bar__');
23349 assert.deepEqual(_.toUpper('--Foo-Bar'), '--FOO-BAR');
23350 assert.deepEqual(_.toUpper('fooBar'), 'FOOBAR');
23351 assert.deepEqual(_.toUpper('__FOO_BAR__'), '__FOO_BAR__');
23361 func = _[methodName];
23413 var func = _[methodName],
23444 assert.strictEqual(_.toLength(-1), 0);
23445 assert.strictEqual(_.toLength('1'), 1);
23446 assert.strictEqual(_.toLength(1.1), 1);
23447 assert.strictEqual(_.toLength(MAX_INTEGER), MAX_ARRAY_LENGTH);
23453 assert.strictEqual(_.toLength(0), 0);
23454 assert.strictEqual(_.toLength(3), 3);
23455 assert.strictEqual(_.toLength(MAX_ARRAY_LENGTH), MAX_ARRAY_LENGTH);
23461 assert.strictEqual(1 / _.toLength(-0), Infinity);
23470 var func = _[methodName];
23492 var func = _[methodName],
23731 assert.strictEqual(_.entries, _.toPairs);
23743 assert.strictEqual(_.entriesIn, _.toPairsIn);
23752 var func = _[methodName],
23833 assert.deepEqual(_.toPath('a.b.c'), ['a', 'b', 'c']);
23834 assert.deepEqual(_.toPath('a[0].b.c'), ['a', '0', 'b', 'c']);
23843 var actual = _.toPath(value);
23852 assert.notStrictEqual(_.toPath('a.b.c'), _.toPath('a.b.c'));
23861 var actual = _.toPath(value);
23873 var actual = _.toPath('a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g');
23881 assert.deepEqual(_.toPath('.a'), expected);
23882 assert.deepEqual(_.toPath('[].a'), expected);
23885 assert.deepEqual(_.toPath('..a'), expected);
23886 assert.deepEqual(_.toPath('[][].a'), expected);
23889 assert.deepEqual(_.toPath('a..b'), expected);
23890 assert.deepEqual(_.toPath('a[].b'), expected);
23893 assert.deepEqual(_.toPath('a...b'), expected);
23894 assert.deepEqual(_.toPath('a[][].b'), expected);
23897 assert.deepEqual(_.toPath('a.'), expected);
23898 assert.deepEqual(_.toPath('a[]'), expected);
23901 assert.deepEqual(_.toPath('a..'), expected);
23902 assert.deepEqual(_.toPath('a[][]'), expected);
23919 var actual = lodashStable.assign({ 'a': 1 }, _.toPlainObject(new Foo));
23926 var actual = _.toPlainObject(args),
23935 var actual = _.toPlainObject(['a', 'b', 'c']),
23954 return index ? _.toString(value) : _.toString();
23965 actual = lodashStable.map(values, _.toString);
23974 assert.deepEqual(_.toString(values), '-0,-0,0,0');
23982 assert.strictEqual(_.toString(symbol), 'Symbol(a)');
23997 assert.strictEqual(_.toString([symbol]), 'Symbol(a)');
24011 var wrapped = _([1, 2, 3]);
24043 return index ? _.transform(object, iteratee, accumulator) : _.transform(object, iteratee);
24080 return lodashStable.isArray(_.transform(array, noop));
24093 return _.transform(value, function(result, value) {
24104 return _.transform(value, function(result, value, key) {
24113 return _.transform(value, noop, accumulator);
24120 assert.strictEqual(_.transform(null, null, accumulator), accumulator);
24127 var actual = _.transform(Array(1), function(result, value, index) {
24137 assert.ok(_.transform(new Foo) instanceof Foo);
24148 return _.transform(value);
24166 assert.notOk(_.transform(new Foo) instanceof Foo);
24176 return index ? _.transform(object) : _.transform();
24192 _.transform(object, function() {
24218 result = _.transform(object);
24238 var func = _[methodName],
24323 assert.strictEqual(_(string)[methodName](), expected);
24335 assert.ok(_(string).chain()[methodName]() instanceof _);
24363 var allHearts = _.repeat(hearts, 10),
24369 assert.strictEqual(_.camelCase(hearts + ' the ' + leafs), hearts + 'The' + leafs);
24370 assert.strictEqual(_.camelCase(string), 'a' + leafs + comboGlyph + 'And' + rocket);
24371 assert.strictEqual(_.capitalize(rocket), rocket);
24373 assert.strictEqual(_.pad(string, 16), ' ' + string + ' ');
24374 assert.strictEqual(_.padStart(string, 16), ' ' + string);
24375 assert.strictEqual(_.padEnd(string, 16), string + ' ');
24377 assert.strictEqual(_.pad(string, 16, chars), hearts + string + chars);
24378 assert.strictEqual(_.padStart(string, 16, chars), chars + hearts + string);
24379 assert.strictEqual(_.padEnd(string, 16, chars), string + chars + hearts);
24381 assert.strictEqual(_.size(string), 13);
24382 assert.deepEqual(_.split(string, ' '), ['A', leafs + ',', comboGlyph + ',', 'and', rocket]);
24383 assert.deepEqual(_.split(string, ' ', 3), ['A', leafs + ',', comboGlyph + ',']);
24384 assert.deepEqual(_.split(string, undefined), [string]);
24385 assert.deepEqual(_.split(string, undefined, -1), [string]);
24386 assert.deepEqual(_.split(string, undefined, 0), []);
24390 assert.deepEqual(_.split(string, ''), expected);
24391 assert.deepEqual(_.split(string, '', 6), expected.slice(0, 6));
24392 assert.deepEqual(_.toArray(string), expected);
24394 assert.strictEqual(_.trim(trimString, chars), string);
24395 assert.strictEqual(_.trimStart(trimString, chars), string + trimChars);
24396 assert.strictEqual(_.trimEnd(trimString, chars), trimChars + string);
24398 assert.strictEqual(_.truncate(string, { 'length': 13 }), string);
24399 assert.strictEqual(_.truncate(string, { 'length': 6 }), 'A ' + leafs + '...');
24401 assert.deepEqual(_.words(string), ['A', leafs, comboGlyph, 'and', rocket]);
24402 assert.deepEqual(_.toArray(hashKeycap), [hashKeycap]);
24403 assert.deepEqual(_.toArray(noMic), [noMic]);
24408 actual = _.truncate(string, options);
24413 actual = _.truncate(allHearts, options);
24431 return [_.size(value), _.toArray(value), _.words(value)];
24449 return [_.size(value), _.toArray(value), _.words(value)];
24461 assert.strictEqual(_.size(flag), 1);
24462 assert.strictEqual(_.size(regionals), 3);
24464 assert.deepEqual(_.toArray(flag), [flag]);
24465 assert.deepEqual(_.toArray(regionals), [pair[0], ' ', pair[1]]);
24467 assert.deepEqual(_.words(flag), [flag]);
24468 assert.deepEqual(_.words(regionals), [pair[0], pair[1]]);
24474 assert.strictEqual(_.size(heart), 1);
24475 assert.deepEqual(_.toArray(heart), [heart]);
24476 assert.deepEqual(_.words(heart), [heart]);
24491 return [_.size(value), _.toArray(value), _.words(value)];
24503 assert.strictEqual(_.size(surrogates), 3);
24504 assert.deepEqual(_.toArray(surrogates), [pair[0], ' ', pair[1]]);
24505 assert.deepEqual(_.words(surrogates), []);
24512 assert.deepEqual(_.toArray(string), [fitzModifiers[0], fitzModifiers[0]]);
24528 var actual = lodashStable.map(['6', '8', '10'], _.unary(parseInt));
24535 var capped = _.unary(fn);
24542 var capped = _.unary(function(a, b) { return this; }),
24563 assert.strictEqual(_.unescape('&lt;'), '<');
24569 assert.strictEqual(_.unescape(escaped), unescaped);
24575 assert.strictEqual(_.unescape('abc'), 'abc');
24581 assert.strictEqual(_.unescape(_.escape(unescaped)), unescaped);
24588 assert.strictEqual(_.unescape(entity), entity);
24598 var func = _[methodName];
24639 var actual = _.unionBy([2.1], [1.2, 2.3], Math.floor);
24642 actual = _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
24651 _.unionBy([2.1], [1.2, 2.3], function() {
24661 var actual = _.unionBy([{ 'x': 1, 'y': 1 }], [{ 'x': 1, 'y': 2 }], 'x');
24676 actual = _.unionWith(objects, others, lodashStable.isEqual);
24687 var actual = _.unionWith(objects, others, function(a, b) {
24700 var func = _[methodName],
24705 objects = _.sortBy(objects, 'a');
24864 var func = _[methodName],
24869 objects = _.sortBy(objects, 'a');
24950 actual = _.uniqWith(objects, lodashStable.isEqual);
24966 return lodashStable.map(_.uniqWith(array, lodashStable.eq), lodashStable.toString);
24982 return _.uniqueId();
24991 assert.strictEqual(typeof _.uniqueId(), 'string');
24997 var actual = [_.uniqueId(3), _.uniqueId(2), _.uniqueId(1)];
25012 assert.strictEqual(_.unset(object, path), true);
25025 return [_.unset(object, key), lodashStable.toString(key) in object];
25038 assert.strictEqual(_.unset(object, symbol), true);
25051 assert.strictEqual(_.unset(object, path), true);
25066 assert.strictEqual(_.unset(object, path), true);
25077 assert.strictEqual(_.unset(object, path), true);
25091 return [_.unset(value, 'a.b'), _.unset(value, ['a', 'b'])];
25109 var actual = _.unset(0, path);
25119 var actual = _.unset(object, path);
25139 assert.strictEqual(_.unset(object, 'a'), false);
25157 var actual = _.unzipWith(array, function(a, b, c) {
25169 _.unzipWith([[1, 3, 5], [2, 4, 6]], function() {
25181 expected = lodashStable.map(values, lodashStable.constant(_.unzip(array)));
25184 return index ? _.unzipWith(array, value) : _.unzipWith(array);
25199 var actual = _.updateWith({ '0': {} }, '[0][1][2]', stubThree, function(value) {
25209 var actual = _.updateWith({}, 'a[0].b.c', stubFour, noop);
25219 var func = _[methodName],
25248 assert.strictEqual(_.upperCase('--foo-bar--'), 'FOO BAR');
25249 assert.strictEqual(_.upperCase('fooBar'), 'FOO BAR');
25250 assert.strictEqual(_.upperCase('__foo_bar__'), 'FOO BAR');
25262 assert.strictEqual(_.upperFirst('fred'), 'Fred');
25263 assert.strictEqual(_.upperFirst('Fred'), 'Fred');
25264 assert.strictEqual(_.upperFirst('FRED'), 'FRED');
25273 var func = _[methodName],
25330 var actual = _.without([2, 1, 2, 3], 1, 2);
25341 assert.deepEqual(_.without(array, { 'a': 1 }), array);
25342 assert.deepEqual(_.without(array, object1), [object2]);
25349 assert.deepEqual(_.without(array, 1, 2), [3, 3]);
25366 return _.words(letter);
25375 assert.deepEqual(_.words('abcd', /ab|cd/g), ['ab', 'cd']);
25376 assert.deepEqual(_.words('abcd', 'ab|cd'), ['ab']);
25382 assert.deepEqual(_.words('12ft'), ['12', 'ft']);
25383 assert.deepEqual(_.words('aeiouAreVowels'), ['aeiou', 'Are', 'Vowels']);
25384 assert.deepEqual(_.words('enable 6h format'), ['enable', '6', 'h', 'format']);
25385 assert.deepEqual(_.words('enable 24H format'), ['enable', '24', 'H', 'format']);
25386 assert.deepEqual(_.words('isISO8601'), ['is', 'ISO', '8601']);
25387 assert.deepEqual(_.words('LETTERSAeiouAreVowels'), ['LETTERS', 'Aeiou', 'Are', 'Vowels']);
25388 assert.deepEqual(_.words('tooLegit2Quit'), ['too', 'Legit', '2', 'Quit']);
25389 assert.deepEqual(_.words('walk500Miles'), ['walk', '500', 'Miles']);
25390 assert.deepEqual(_.words('xhr2Request'), ['xhr', '2', 'Request']);
25391 assert.deepEqual(_.words('XMLHttp'), ['XML', 'Http']);
25392 assert.deepEqual(_.words('XmlHTTP'), ['Xml', 'HTTP']);
25393 assert.deepEqual(_.words('XmlHttp'), ['Xml', 'Http']);
25399 assert.deepEqual(_.words('LETTERSÆiouAreVowels'), ['LETTERS', 'Æiou', 'Are', 'Vowels']);
25400 assert.deepEqual(_.words('æiouAreVowels'), ['æiou', 'Are', 'Vowels']);
25401 assert.deepEqual(_.words('æiou2Consonants'), ['æiou', '2', 'Consonants']);
25413 return _.words(string[index ? 'toUpperCase' : 'toLowerCase']());
25439 return _.words(words[0]);
25451 actual = lodashStable.map(operators, _.words);
25466 actual = lodashStable.map(marks, _.words);
25475 actual = lodashStable.map(strings, _.words);
25484 largeWord = _.repeat('A', largeWordLen),
25488 assert.deepEqual(_.words(largeWord + 'ÆiouAreVowels'), [largeWord, 'Æiou', 'Are', 'Vowels']);
25505 var p = _.wrap(lodashStable.escape, function(func, text) {
25517 var wrapped = _.wrap(noop, function() {
25532 var wrapped = index ? _.wrap('a', value) : _.wrap('a');
25542 var p = _.wrap(lodashStable.escape, function(func) {
25556 var func = _[methodName];
25621 var wrapped = _([1, 2, 3])[methodName]([5, 2, 1, 4]);
25622 assert.ok(wrapped instanceof _);
25634 wrapped = _(array).slice(1)[methodName]([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]);
25656 var actual = _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
25659 actual = _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
25668 _.xorBy([2.1, 1.2], [2.3, 3.4], function() {
25686 actual = _.xorWith(objects, others, lodashStable.isEqual);
25697 var func = _[methodName],
25735 actual = _(props)[methodName](values).map(square).filter(isEven).take().value();
25737 assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
25757 var actual = _.zipWith(array1, array2, array3, function(a, b, c) {
25763 var actual = _.zipWith(array1, [], function(a, b) {
25775 _.zipWith([1, 2], [3, 4], [5, 6], function() {
25788 expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2)));
25791 return index ? _.zipWith(array1, array2, value) : _.zipWith(array1, array2);
25803 var func = _[methodName];
25889 wrapped = _(array).push(2).push(3);
25894 assert.ok(otherWrapper instanceof _);
25907 var wrapped = _([1]).chain().commit().head();
25908 assert.ok(wrapped instanceof _);
25923 return implicit ? _(value) : _.chain(value);
25967 assert.deepEqual(Array.from(wrapped), _.toArray(value));
26006 …assert.deepEqual(lodashStable.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain…
26026 wrapped1 = _(array1).thru(_.compact).map(square).takeRight(2).sort(),
26043 wrapped1 = _(array1).chain().map(square),
26059 wrapped1 = _(array1).map(square);
26083 wrapped = _(array);
26106 var result = index ? _(value).pop() : _().pop();
26129 wrapped = _(array).push(2, 3),
26148 var result = index ? _(value).push(1).value() : _().push(1).value();
26171 wrapped = _(array);
26194 var result = index ? _(value).shift() : _().shift();
26217 wrapped = _(array).sort(),
26236 var result = index ? _(value).sort().value() : _().sort().value();
26259 wrapped = _(array);
26282 var result = index ? _(value).splice(0, 1).value() : _().splice(0, 1).value();
26305 wrapped = _(array).unshift(1, 2),
26324 var result = index ? _(value).unshift(1).value() : _().unshift(1).value();
26347 wrapped = _(array).push(2).push(3);
26363 var wrapped = _(123);
26375 var wrapped = _([1, 2, 3]);
26387 var expected = _.prototype.value;
26388 assert.strictEqual(_.prototype.toJSON, expected);
26389 assert.strictEqual(_.prototype.valueOf, expected);
26415 wrapped = _(array),
26418 assert.ok(actual instanceof _);
26469 wrapped = _(value),
26472 assert.ok(actual instanceof _);
26588 var actual = _()[methodName]();
26589 assert.notOk(actual instanceof _);
26600 var actual = _().chain()[methodName]();
26601 assert.ok(actual instanceof _);
26626 assert.deepEqual(_.difference(args, [null]), [1, [3], 5], message('difference'));
26627 …assert.deepEqual(_.difference(array, args), [2, 3, 4, 6], '_.difference should work with `argument…
26629 assert.deepEqual(_.union(args, [null, 6]), [1, null, [3], 5, 6], message('union'));
26630 …assert.deepEqual(_.union(array, args), array.concat([null, [3]]), '_.union should work with `argum…
26632 assert.deepEqual(_.compact(args), [1, [3], 5], message('compact'));
26633 assert.deepEqual(_.drop(args, 3), [null, 5], message('drop'));
26634 assert.deepEqual(_.dropRight(args, 3), [1, null], message('dropRight'));
26635 …assert.deepEqual(_.dropRightWhile(args,identity), [1, null, [3], null], message('dropRightWhile'));
26636 assert.deepEqual(_.dropWhile(args,identity), [null, [3], null, 5], message('dropWhile'));
26637 assert.deepEqual(_.findIndex(args, identity), 0, message('findIndex'));
26638 assert.deepEqual(_.findLastIndex(args, identity), 4, message('findLastIndex'));
26639 assert.deepEqual(_.flatten(args), [1, null, 3, null, 5], message('flatten'));
26640 assert.deepEqual(_.head(args), 1, message('head'));
26641 assert.deepEqual(_.indexOf(args, 5), 4, message('indexOf'));
26642 assert.deepEqual(_.initial(args), [1, null, [3], null], message('initial'));
26643 assert.deepEqual(_.intersection(args, [1]), [1], message('intersection'));
26644 assert.deepEqual(_.last(args), 5, message('last'));
26645 assert.deepEqual(_.lastIndexOf(args, 1), 0, message('lastIndexOf'));
26646 assert.deepEqual(_.sortedIndex(sortedArgs, 6), 3, message('sortedIndex'));
26647 assert.deepEqual(_.sortedIndexOf(sortedArgs, 5), 2, message('sortedIndexOf'));
26648 assert.deepEqual(_.sortedLastIndex(sortedArgs, 5), 3, message('sortedLastIndex'));
26649 assert.deepEqual(_.sortedLastIndexOf(sortedArgs, 1), 0, message('sortedLastIndexOf'));
26650 assert.deepEqual(_.tail(args, 4), [null, [3], null, 5], message('tail'));
26651 assert.deepEqual(_.take(args, 2), [1, null], message('take'));
26652 assert.deepEqual(_.takeRight(args, 1), [5], message('takeRight'));
26653 assert.deepEqual(_.takeRightWhile(args, identity), [5], message('takeRightWhile'));
26654 assert.deepEqual(_.takeWhile(args, identity), [1], message('takeWhile'));
26655 assert.deepEqual(_.uniq(args), [1, null, [3], 5], message('uniq'));
26656 assert.deepEqual(_.without(args, null), [1, [3], 5], message('without'));
26657 …assert.deepEqual(_.zip(args, args), [[1, 1], [null, null], [[3], [3]], [null, null], [5, 5]], mess…
26667 assert.deepEqual(_.difference(null, array), [], message('difference'));
26668 assert.deepEqual(_.intersection(null, array), [], message('intersection'));
26669 assert.deepEqual(_.union(null, array), array, message('union'));
26670 assert.deepEqual(_.xor(null, array), array, message('xor'));
26680 assert.deepEqual(_.difference(array, null), array, message('difference'));
26681 assert.deepEqual(_.intersection(array, null), [], message('intersection'));
26682 assert.deepEqual(_.union(array, null), array, message('union'));
26715 var func = _[methodName];
26737 var allMethods = lodashStable.reject(_.functions(_).sort(), function(methodName) {
26831 func = _[methodName];
26838 root._ = oldDash;
26851 if (!_[methodName]) {
26864 func = _[methodName];
26888 func = _[methodName];
26911 func = _[methodName],
26916 var wrapper = func(_.bind(fn, object));
26919 wrapper = _.bind(func(fn), object);
26931 assert.ok(lodashStable.every(_.functions(_), function(methodName) {