Lines Matching refs:map
78 map = Map ? new Map : undefined, variable
902 var map = new lodashBizarro.memoize.Cache;
903 actual = map.set('a', 1).get('a');
911 map = new (Map || Object);
913 map[Symbol.iterator] = null;
915 actual = lodashBizarro.toArray(map);
940 expected = lodashStable.map(values, stubTrue);
942 var actual = lodashStable.map(values, function(args) {
958 expected = lodashStable.map(values, stubFalse);
960 var actual = lodashStable.map(values, function(args) {
1047 var pairs = lodashStable.map(keys, function(key, index) {
1114 expected = lodashStable.map(values, stubTrue);
1120 var actual = lodashStable.map(values, function(value) {
1135 var actual = lodashStable.map(values, function(value) {
1151 var actual = lodashStable.map(values, function(value) {
1238 var actual = lodashStable.map(['6', '8', '10'], _.ary(parseInt, 1));
1270 var actual = lodashStable.map(values, function(n) {
1284 var expected = lodashStable.map(args, function(arg, index) {
1288 var actual = lodashStable.map(expected, function(array) {
1314 var funcs = lodashStable.map([fn], _.ary),
1523 var expected = lodashStable.map(values, stubOne),
1546 var expected = lodashStable.map(falsey, lodashStable.constant(Array(4)));
1548 var actual = lodashStable.map(falsey, function(object) {
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));
1676 var expected = lodashStable.map(errors, stubTrue);
1678 var actual = lodashStable.map(errors, function(error) {
1703 var expected = lodashStable.map(realm.errors, stubTrue);
1705 var actual = lodashStable.map(realm.errors, function(error) {
1801 expected = lodashStable.map(values, function(value) { return [value]; });
1803 var actual = lodashStable.map(values, function(value) {
2078 var actual = lodashStable.map(['a', 'b', 'c'], function(key) {
2091 var actual = lodashStable.map(['a', 'b', 'c', 'd'], function(key) {
2103 var actual = lodashStable.map(props, function(key) {
2126 var actual = lodashStable.map(args, function(key) {
2241 var actual = lodashStable.map(strings, function(string) {
2246 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2252 var actual = lodashStable.map(strings, function(string) {
2257 assert.deepEqual(actual, lodashStable.map(strings, stubTrue));
2263 var actual = lodashStable.map(burredLetters, function(burred, index) {
2275 assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue));
2284 var actual = lodashStable.map(postfixes, function(postfix) {
2288 var expected = lodashStable.map(postfixes, function(postfix) {
2306 var actual = lodashStable.map(['\xd7', '\xf7'], func);
2411 expected = lodashStable.map(values, function(value) { return [value]; }),
2412 actual = lodashStable.map(values, _.castArray);
2492 .map(function(value) { return value.split(''); })
2521 .map(square)
2557 var expected = lodashStable.map(falsey, function(value) {
2561 var actual = lodashStable.map(falsey, function(size, index) {
2572 expected = lodashStable.map(values, stubArray);
2574 var actual = lodashStable.map(values, function(n) {
2590 var actual = lodashStable.map([[1, 2], [3, 4]], _.chunk);
2689 var map = new Map; variable
2690 map.set('a', 1);
2691 map.set('b', 2);
2709 'maps': map,
2862 var values = lodashStable.map([false, true, 1, 'a'], function(value) {
2868 var expected = lodashStable.map(values, stubTrue);
2870 var actual = lodashStable.map(values, function(value) {
3028 var expected = lodashStable.map(objects, stubTrue);
3030 var actual = lodashStable.map(objects, function(object) {
3044 actual = lodashStable.map(expected, func);
3257 var expected = lodashStable.map(values, function(value, index) {
3261 var actual = lodashStable.map(values, function(value, index) {
3267 expected = lodashStable.map(values, function(value) {
3271 actual = lodashStable.map(values, function(value) {
3528 expected = lodashStable.map(values, stubFalse);
3534 var actual = lodashStable.map(values, function(value, index) {
3547 expected = lodashStable.map(values, stubTrue),
3550 var actual = lodashStable.map(values, function(value, index) {
3563 expected = lodashStable.map(empties, stubTrue);
3565 var actual = lodashStable.map(empties, function(value) {
3586 var results = lodashStable.map(values, function(value, index) {
3601 var expected = lodashStable.map(falsey, stubTrue);
3603 var actual = lodashStable.map(falsey, function(value, index) {
3645 expected = lodashStable.map(values, lodashStable.constant({ '4': 1, '6': 2 }));
3647 var actual = lodashStable.map(values, function(value, index) {
3701 var actual = _(array).countBy().map(square).filter(isEven).take().value();
3703 assert.deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), isEven)));
3776 var expected = lodashStable.map(falsey, stubObject);
3778 var actual = lodashStable.map(falsey, function(prototype, index) {
3788 var expected = lodashStable.map(primitives, stubTrue);
3790 var actual = lodashStable.map(primitives, function(value, index) {
3801 expected = lodashStable.map(array, stubTrue),
3802 objects = lodashStable.map(array, _.create);
3804 var actual = lodashStable.map(objects, function(object) {
3847 expected = lodashStable.map(values, stubArray);
3849 var actual = lodashStable.map(values, function(arity) {
4005 expected = lodashStable.map(values, stubArray);
4007 var actual = lodashStable.map(values, function(arity) {
4173 var curries = lodashStable.map(collection, func),
4174 … expected = lodashStable.map(collection, lodashStable.constant(isCurry ? ['a', 'b'] : ['b', 'a']));
4176 var actual = lodashStable.map(curries, function(curried) {
4492 var actual = lodashStable.map(burredLetters, _.deburr);
4500 actual = lodashStable.map(operators, _.deburr);
4508 var expected = lodashStable.map(comboMarks, lodashStable.constant('ei'));
4510 var actual = lodashStable.map(comboMarks, function(chr) {
4736 var expected = lodashStable.map(falsey, function(value) {
4740 var actual = lodashStable.map(falsey, function(value) {
4918 var actual = lodashStable.map(array, function(value) {
4924 actual = lodashStable.map(func([-0, 1], [1]), lodashStable.toString);
4954 var actual = lodashStable.map(array, function(value) {
4962 actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString);
5042 expected = lodashStable.map(others, lodashStable.constant(['-0']));
5044 var actual = lodashStable.map(others, function(other) {
5045 … return lodashStable.map(_.differenceWith(array, other, lodashStable.eq), lodashStable.toString);
5089 var expected = lodashStable.map(falsey, function(value) {
5093 var actual = lodashStable.map(falsey, function(n) {
5126 actual = lodashStable.map(array, _.drop);
5177 var expected = lodashStable.map(falsey, function(value) {
5181 var actual = lodashStable.map(falsey, function(n) {
5214 actual = lodashStable.map(array, _.dropRight);
5446 var expected = lodashStable.map(falsey, stubTrue);
5448 var actual = lodashStable.map(falsey, function(position) {
5560 expected = lodashStable.map(values, stubString);
5562 var actual = lodashStable.map(values, function(value, index) {
5584 var expected = lodashStable.map(empties, stubTrue);
5586 var actual = lodashStable.map(empties, function(value) {
5618 expected = lodashStable.map(values, stubFalse);
5620 var actual = lodashStable.map(values, function(value, index) {
5627 expected = lodashStable.map(values, stubTrue);
5628 actual = lodashStable.map(values, function(value, index) {
5655 var actual = lodashStable.map([[1]], _.every);
5726 var expected = lodashStable.map(falsey, lodashStable.constant(['a', 'a', 'a']));
5728 var actual = lodashStable.map(falsey, function(start) {
5780 var expected = lodashStable.map(falsey, function(value) {
5784 var actual = lodashStable.map(falsey, function(end) {
5813 var actual = lodashStable.map(positions, function(pos) {
5825 actual = lodashStable.map(array, _.fill);
5919 expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
5921 var actual = lodashStable.map(emptyValues, function(value) {
6060 actual = _(array).map(iteratee)[methodName](predicate);
6109 var expected = lodashStable.map(indexes, function() {
6114 var actual = lodashStable.map(indexes, function(fromIndex) {
6128 var expected = lodashStable.map(falsey, lodashStable.constant(isIncludes || values[0]));
6130 var actual = lodashStable.map(falsey, function(fromIndex) {
6175 expected = lodashStable.map(indexes, lodashStable.constant(isIncludes || values[0]));
6177 var actual = lodashStable.map(indexes, function(fromIndex) {
6211 expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1]));
6213 var actual = lodashStable.map(values, function(fromIndex) {
6234 expected = lodashStable.map(values, stubZero);
6236 var actual = lodashStable.map(values, function(fromIndex) {
6246 var expected = lodashStable.map(falsey, stubZero);
6248 var actual = lodashStable.map(falsey, function(fromIndex) {
6297 …var expected = lodashStable.map(indexes, lodashStable.constant([values[0], undefined, undefined]));
6299 var actual = lodashStable.map(indexes, function(fromIndex) {
6313 var expected = lodashStable.map(falsey, function(value) {
6317 var actual = lodashStable.map(falsey, function(fromIndex) {
6362 expected = lodashStable.map(indexes, lodashStable.constant(values[0]));
6364 var actual = lodashStable.map(indexes, function(fromIndex) {
6407 expected = lodashStable.map(values, lodashStable.constant([1, 2, [3, [4]], 5]));
6409 var actual = lodashStable.map(values, function(value, index) {
6447 expected = lodashStable.flatten(lodashStable.map(array, duplicate));
6477 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3, 4]));
6480 var actual = lodashStable.map(values, function(value, index) {
6491 var expected = lodashStable.map(falsey, stubArray);
6493 var actual = lodashStable.map(falsey, function(collection, index) {
6583 expected = lodashStable.map(methodNames, lodashStable.constant(['a']));
6587 var actual = lodashStable.map(methodNames, function(methodName) {
6736 var map1 = _.map,
6737 map2 = _.curry(_.rearg(_.ary(_.map, 2), 1, 0), 2),
6738 map3 = (_.map = index ? map2 : map1, map2(iteratee));
6759 _.map = map1;
6767 var curried = _.curry(_.ary(_.map, 2), 2),
7026 expected = lodashStable.map(expected, function(args) {
7031 expected = lodashStable.map(expected, function(args) {
7178 expected = lodashStable.map(values, stubTrue);
7180 var actual = lodashStable.map(values, function(length) {
7266 var expected = lodashStable.map(primitives, function(value) {
7272 var actual = lodashStable.map(primitives, function(value) {
7315 expected = lodashStable.map(values, stubTrue);
7317 var actual = lodashStable.map(values, function(value) {
7324 actual = lodashStable.map(values, function(value) {
7408 expected = lodashStable.map([1, 2, 'a', object, source], lodashStable.cloneDeep);
7411 args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
7422 …expected = [lodashStable.map([objectValue, sourceValue, 'a', object, source], lodashStable.cloneDe…
7425 …expected.push(lodashStable.map([undefined, 2, 'b', objectValue, sourceValue], lodashStable.cloneDe…
7428 argsList.push(lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
7436 expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep);
7439 args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
7541 var expected = lodashStable.map(methods, stubFalse);
7543 var actual = lodashStable.map(methods, function(methodName) {
7617 var expected = lodashStable.map(falsey, stubObject);
7619 var actual = lodashStable.map(falsey, function(array, index) {
7650 var actual = _(array).fromPairs().map(square).filter(isEven).take().value();
7652 assert.deepEqual(actual, _.take(_.filter(_.map(_.fromPairs(array), square), isEven)));
7706 expected = lodashStable.map(values, lodashStable.constant({ '4': [4], '6': [6, 6] }));
7708 var actual = lodashStable.map(values, function(value, index) {
7764 actual = _(array).groupBy().map(iteratee).filter(predicate).take().value();
7766 …assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))…
7871 expected = lodashStable.map(paths, stubTrue);
7874 var actual = lodashStable.map(paths, function(path) {
7903 expected = lodashStable.map(props, stubTrue);
7905 var actual = lodashStable.map(props, function(key) {
7951 expected = lodashStable.map(values, stubTrue);
7953 var actual = lodashStable.map(values, function(value) {
7964 expected = lodashStable.map(values, lodashStable.constant([true, true]));
7966 var actual = lodashStable.map(values, function(value) {
7967 return lodashStable.map(['a[0]', ['a', '0']], function(path) {
8001 expected = lodashStable.map(values, stubFalse);
8004 var actual = lodashStable.map(values, function(value) {
8016 expected = lodashStable.map(values, stubFalse);
8019 var actual = lodashStable.map(values, function(value) {
8031 expected = lodashStable.map(values, stubFalse);
8034 var actual = lodashStable.map(values, function(value, index) {
8047 expected = lodashStable.map(values, lodashStable.constant([false, false]));
8049 var actual = lodashStable.map(values, function(value) {
8050 return lodashStable.map(['a[0].b', ['a', '0', 'b']], function(path) {
8084 actual = lodashStable.map(array, _.head);
8238 var expected = lodashStable.map(empties, stubFalse);
8240 var actual = lodashStable.map(empties, function(value) {
8256 var expected = lodashStable.map(indexes, function(index) {
8260 var actual = lodashStable.map(indexes, function(fromIndex) {
8304 var expected = lodashStable.map(falsey, stubArray);
8306 var actual = lodashStable.map(falsey, function(array, index) {
8331 actual = lodashStable.map(array, _.initial);
8432 assert.deepEqual(actual, lodashStable.map(actual, stubTrue));
8485 expected = lodashStable.map(values, lodashStable.constant(['0']));
8487 var actual = lodashStable.map(values, function(value) {
8488 return lodashStable.map(func(values, [value]), lodashStable.toString);
8505 expected = lodashStable.map(values, lodashStable.constant(['0']));
8507 var actual = lodashStable.map(values, function(value) {
8509 return lodashStable.map(func(values, largeArray), lodashStable.toString);
8604 expected = lodashStable.map(others, lodashStable.constant(['-0']));
8606 var actual = lodashStable.map(others, function(other) {
8607 … return lodashStable.map(_.intersectionWith(array, other, lodashStable.eq), lodashStable.toString);
8682 … expected = lodashStable.map(values, lodashStable.constant({ '1': ['a', 'c'], '2': ['b'] }));
8684 var actual = lodashStable.map(values, function(value, index) {
8742 expected = lodashStable.map(values, noop);
8744 var actual = lodashStable.map(values, function(value) {
8759 var actual = lodashStable.map(props, function(key) {
8877 var objects = lodashStable.map([null, undefined, stubOne], function(value) {
8881 var expected = lodashStable.map(objects, function(object) {
8962 var expected = lodashStable.map(falsey, stubFalse);
8964 var actual = lodashStable.map(falsey, function(value, index) {
9009 var expected = lodashStable.map(falsey, stubFalse);
9011 var actual = lodashStable.map(falsey, function(value, index) {
9061 var expected = lodashStable.map(falsey, stubFalse);
9063 var actual = lodashStable.map(falsey, function(value, index) {
9104 expected = lodashStable.map(values, stubTrue),
9105 actual = lodashStable.map(values, _.isArrayLike);
9113 var expected = lodashStable.map(falsey, function(value) {
9117 var actual = lodashStable.map(falsey, function(value, index) {
9141 expected = lodashStable.map(values, stubTrue),
9142 actual = lodashStable.map(values, _.isArrayLike);
9169 var expected = lodashStable.map(falsey, function(value) {
9173 var actual = lodashStable.map(falsey, function(value, index) {
9223 var expected = lodashStable.map(falsey, stubFalse);
9225 var actual = lodashStable.map(falsey, function(value, index) {
9271 var expected = lodashStable.map(falsey, stubFalse);
9273 var actual = lodashStable.map(falsey, function(value, index) {
9333 var expected = lodashStable.map(falsey, stubFalse);
9335 var actual = lodashStable.map(falsey, function(value, index) {
9386 var expected = lodashStable.map(empties, stubTrue),
9387 actual = lodashStable.map(empties, _.isEmpty);
9455 lodashStable.each([new Map, realm.map], function(map) { argument
9456 assert.strictEqual(_.isEmpty(map), true);
9457 map.set('a', 1);
9458 assert.strictEqual(_.isEmpty(map), false);
9459 map.clear();
9553 var expected = lodashStable.map(pairs, function(pair) {
9557 var actual = lodashStable.map(pairs, function(pair) {
9609 array1.indexOf = array1.lastIndexOf = array1.map =
9964 var pairs = lodashStable.map(arrayViews, function(type, viewIndex) {
9975 var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
9977 var actual = lodashStable.map(pairs, function(pair) {
10014 var pairs = lodashStable.map([
10030 var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
10032 var actual = lodashStable.map(pairs, function(pair) {
10053 lodashStable.each([[map, new Map], [map, realm.map]], function(maps) {
10315 expected = lodashStable.map(values, stubFalse);
10317 var actual = lodashStable.map(values, function(value) {
10420 expected = lodashStable.map(values, stubFalse);
10435 actual = lodashStable.map([array, [1, 0, 3]], eq);
10498 var expected = lodashStable.map(errors, stubTrue);
10500 var actual = lodashStable.map(errors, function(error) {
10516 var expected = lodashStable.map(falsey, stubFalse);
10518 var actual = lodashStable.map(falsey, function(value, index) {
10547 var expected = lodashStable.map(realm.errors, stubTrue);
10549 var actual = lodashStable.map(realm.errors, function(error) {
10570 expected = lodashStable.map(values, stubTrue),
10571 actual = lodashStable.map(values, _.isFinite);
10580 expected = lodashStable.map(values, stubFalse),
10581 actual = lodashStable.map(values, _.isFinite);
10590 expected = lodashStable.map(values, stubFalse),
10591 actual = lodashStable.map(values, _.isFinite);
10610 expected = lodashStable.map(values, stubFalse),
10611 actual = lodashStable.map(values, _.isFinite);
10655 var expected = lodashStable.map(arrayViews, function(type) {
10659 var actual = lodashStable.map(arrayViews, function(type) {
10669 var expected = lodashStable.map(falsey, stubFalse);
10671 var actual = lodashStable.map(falsey, function(value, index) {
10720 expected = lodashStable.map(values, stubTrue);
10722 var actual = lodashStable.map(values, function(value) {
10734 expected = lodashStable.map(values, stubFalse);
10736 var actual = lodashStable.map(values, function(value) {
10746 var expected = lodashStable.map(falsey, function(value) {
10750 var actual = lodashStable.map(falsey, function(value, index) {
10777 expected = lodashStable.map(values, stubTrue),
10778 actual = lodashStable.map(values, _.isLength);
10787 expected = lodashStable.map(values, stubFalse),
10788 actual = lodashStable.map(values, _.isLength);
10803 assert.strictEqual(_.isMap(map), true);
10813 var expected = lodashStable.map(falsey, stubFalse);
10815 var actual = lodashStable.map(falsey, function(value, index) {
10840 expected = lodashStable.map(values, stubFalse);
10842 var actual = lodashStable.map(values, function(value) {
10852 if (realm.map) {
10853 assert.strictEqual(_.isMap(realm.map), true);
10930 var expected = lodashStable.map(falsey, stubFalse);
10960 actual = lodashStable.map([object, { 'a': 2 }], matches);
11029 var expected = lodashStable.map(falsey, function(value) {
11033 var actual = lodashStable.map(falsey, function(value, index) {
11075 expected = lodashStable.map(values, Boolean),
11076 actual = lodashStable.map(values, _.isNative);
11084 var expected = lodashStable.map(falsey, stubFalse);
11086 var actual = lodashStable.map(falsey, function(value, index) {
11181 var expected = lodashStable.map(falsey, function(value) {
11185 var actual = lodashStable.map(falsey, function(value, index) {
11238 var expected = lodashStable.map(falsey, function(value) {
11242 var actual = lodashStable.map(falsey, function(value, index) {
11290 var expected = lodashStable.map(falsey, function(value) {
11294 var actual = lodashStable.map(falsey, function(value, index) {
11363 expected = lodashStable.map(values, stubFalse);
11365 var actual = lodashStable.map(values, function(value, index) {
11419 expected = lodashStable.map(values, stubFalse);
11421 var actual = lodashStable.map(values, function(value, index) {
11524 var expected = lodashStable.map(falsey, stubFalse);
11526 var actual = lodashStable.map(falsey, function(value, index) {
11599 var expected = lodashStable.map(falsey, stubFalse);
11601 var actual = lodashStable.map(falsey, function(value, index) {
11651 var expected = lodashStable.map(falsey, stubFalse);
11653 var actual = lodashStable.map(falsey, function(value, index) {
11678 expected = lodashStable.map(values, stubFalse);
11680 var actual = lodashStable.map(values, function(value) {
11714 var expected = lodashStable.map(falsey, function(value) {
11718 var actual = lodashStable.map(falsey, function(value, index) {
11769 var expected = lodashStable.map(falsey, stubFalse);
11771 var actual = lodashStable.map(falsey, function(value, index) {
11810 var expected = lodashStable.map(typedArrays, function(type) {
11814 var actual = lodashStable.map(typedArrays, function(type) {
11825 var expected = lodashStable.map(falsey, stubFalse);
11827 var actual = lodashStable.map(falsey, function(value, index) {
11853 var expected = lodashStable.map(props, function(key) {
11857 var actual = lodashStable.map(props, function(key) {
11885 var expected = lodashStable.map(falsey, function(value) {
11889 var actual = lodashStable.map(falsey, function(value, index) {
11946 var expected = lodashStable.map(falsey, stubFalse);
11948 var actual = lodashStable.map(falsey, function(value, index) {
11962 assert.strictEqual(_.isWeakMap(map), false);
11973 expected = lodashStable.map(values, stubFalse);
11975 var actual = lodashStable.map(values, function(value) {
12013 var expected = lodashStable.map(falsey, stubFalse);
12015 var actual = lodashStable.map(falsey, function(value, index) {
12118 … expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object]));
12120 var actual = lodashStable.map(values, function(value, index) {
12263 assert.deepEqual(_.map([{ 'a': 1 }], 'a'), [1]);
12273 iteratees = lodashStable.map(array, _.iteratee),
12274 expected = lodashStable.map(array, stubFalse);
12276 var actual = lodashStable.map(iteratees, function(iteratee) {
12509 assert.deepEqual(_.map(objects), [0, 1, 1]);
12885 expected = lodashStable.map(values, lodashStable.constant({ '4': 4, '6': 6 }));
12887 var actual = lodashStable.map(values, function(value, index) {
12943 var actual = _(array).keyBy().map(square).filter(isEven).take().value();
12945 assert.deepEqual(actual, _.take(_.filter(_.map(_.keyBy(array), square), isEven)));
13022 expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2']));
13024 var actual = lodashStable.map(values, function(value) {
13035 expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2', 'a']));
13037 var actual = lodashStable.map(values, function(value) {
13051 …expected = lodashStable.map(values, lodashStable.constant(isKeys ? ['0', '1', '2'] : ['0', '1', '2…
13053 var actual = lodashStable.map(values, function(value) {
13107 var expected = lodashStable.map(primitives, function(value) {
13111 var actual = lodashStable.map(primitives, func);
13139 expected = lodashStable.map(values, stubArray);
13141 var actual = lodashStable.map(values, function(value, index) {
13178 actual = lodashStable.map(array, _.last);
13334 expected = lodashStable.map(values, lodashStable.constant([-1, 3, -1]));
13336 var actual = lodashStable.map(values, function(fromIndex) {
13357 expected = lodashStable.map(values, stubZero);
13359 var actual = lodashStable.map(values, function(fromIndex) {
13369 var expected = lodashStable.map(falsey, function(value) {
13373 var actual = lodashStable.map(falsey, function(fromIndex) {
13399 var expected = lodashStable.map(falsey, lodashStable.constant(-1));
13401 var actual = lodashStable.map(falsey, function(array, index) {
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);
13501 expected = lodashStable.map(values, lodashStable.constant([1, 2]));
13504 var actual = lodashStable.map(values, function(value, index) {
13505 return index ? _.map(collection, value) : _.map(collection);
13515 var expected = lodashStable.map(falsey, stubArray);
13517 var actual = lodashStable.map(falsey, function(collection, index) {
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() {
13649 expected = lodashStable.map(values, lodashStable.constant({ '1': 1, '2': 2 }));
13651 var actual = lodashStable.map(values, function(value, index) {
13693 expected = lodashStable.map(values, lodashStable.constant([true, false]));
13695 var actual = lodashStable.map(values, function(value, index) {
13727 var expected = lodashStable.map(falsey, stubObject);
13729 var actual = lodashStable.map(falsey, function(object, index) {
13843 actual = lodashStable.map(objects, matches(source)),
13844 expected = lodashStable.map(objects, stubTrue);
13905 actual = lodashStable.map(objects, matches(Foo));
13966 var map = new Map;
13967 map.set('b', 2);
13968 var actual = lodashStable.filter(objects, matches({ 'a': map }));
13972 map.delete('b');
13973 actual = lodashStable.filter(objects, matches({ 'a': map }));
13977 map.set('c', 3);
13978 actual = lodashStable.filter(objects, matches({ 'a': map }));
14021 actual = lodashStable.map(objects, matches({ 'b': undefined })),
14026 actual = lodashStable.map(objects, matches({ 'a': 1, 'b': undefined }));
14031 actual = lodashStable.map(objects, matches({ 'a': { 'c': undefined } }));
14069 expected = lodashStable.map(values, stubFalse),
14072 var actual = lodashStable.map(values, function(value, index) {
14085 expected = lodashStable.map(empties, stubTrue);
14087 var actual = lodashStable.map(empties, function(value) {
14099 expected = lodashStable.map(values, stubTrue),
14102 var actual = lodashStable.map(values, function(value, index) {
14180 expected = lodashStable.map(props, lodashStable.constant([true, false]));
14182 var actual = lodashStable.map(props, function(key, index) {
14200 expected = lodashStable.map(paths, stubTrue);
14203 var actual = lodashStable.map(paths, function(path) {
14227 expected = lodashStable.map(values, stubFalse);
14232 var actual = lodashStable.map(values, function(value, index) {
14246 expected = lodashStable.map(values, stubFalse);
14251 var actual = lodashStable.map(values, function(value, index) {
14295 expected = lodashStable.map(objects, stubTrue);
14298 assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14345 actual = lodashStable.map(objects, _.matchesProperty('a', Foo));
14405 var map = new Map;
14406 map.set('b', 2);
14407 var actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14411 map.delete('b');
14412 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14416 map.set('c', 3);
14417 actual = lodashStable.filter(objects, _.matchesProperty('a', map));
14460 actual = lodashStable.map(objects, _.matchesProperty('b', undefined)),
14466 actual = lodashStable.map(objects, _.matchesProperty('a', { 'b': undefined }));
14562 expected = lodashStable.map(values, noop);
14564 var actual = lodashStable.map(values, function(value, index) {
14595 var expected = lodashStable.map(empties, stubNaN),
14596 actual = lodashStable.map(empties, _.mean);
14728 expected = lodashStable.map(values, stubTrue);
14730 var actual = lodashStable.map(values, function(resolver, index) {
14754 var actual = lodashStable.map(props, function(value) {
15040 var expected = lodashStable.map(typedArrays, function(type, index) {
15046 var actual = lodashStable.map(typedArrays, function(type) {
15054 expected = lodashStable.map(typedArrays, function(type, index) {
15060 actual = lodashStable.map(typedArrays, function(type, index) {
15085 expected = lodashStable.map(values, stubTrue);
15087 var actual = lodashStable.map(values, function(value) {
15120 expected = lodashStable.map(values, stubTrue);
15122 var actual = lodashStable.map(values, function(value, index) {
15246 expected = lodashStable.map(pairs, stubTrue);
15248 var actual = lodashStable.map(pairs, function(pair) {
15386 var actual = lodashStable.map(paths, function(path) {
15422 expected = lodashStable.map(values, noop);
15427 var actual = lodashStable.map(values, function(value, index) {
15439 expected = lodashStable.map(values, noop);
15444 var actual = lodashStable.map(values, function(value, index) {
15540 var actual = lodashStable.map(paths, function(path) {
15576 expected = lodashStable.map(values, noop);
15579 var actual = lodashStable.map(values, function(value, index) {
15592 expected = lodashStable.map(values, noop);
15595 var actual = lodashStable.map(values, function(value, index) {
15658 expected = lodashStable.map(values, noop);
15660 var actual = lodashStable.map(values, function(value, index) {
15978 actual = _(array).a().map(square).b(isEven).take().value();
15980 assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven)));
16045 …expected = lodashStable.map(falsey, lodashStable.constant([objects[3], objects[1], objects[2], obj…
16047 actual = lodashStable.map(falsey, function(order, index) {
16312 var actual = lodashStable.map(array, function(value, index) {
16322 var actual = lodashStable.map(lodashStable.range(1, array.length + 1), function(n) {
16333 expected = lodashStable.map(values, stubA);
16335 var actual = lodashStable.map(values, function(n) {
16342 expected = lodashStable.map(values, stubB);
16344 actual = lodashStable.map(values, function(n) {
16355 expected = lodashStable.map(values, noop);
16357 var actual = lodashStable.map(values, function(array) {
16369 expected = lodashStable.map(values, noop);
16373 var actual = lodashStable.map(values, function(n) {
16391 var actual = lodashStable.map(args, function(value, index) {
16402 var actual = lodashStable.map(lodashStable.range(1, args.length + 1), function(n) {
16414 expected = lodashStable.map(values, stubA);
16416 var actual = lodashStable.map(values, function(n) {
16424 expected = lodashStable.map(values, stubB);
16426 actual = lodashStable.map(values, function(n) {
16445 expected = lodashStable.map(values, noop);
16447 var actual = lodashStable.map(values, function(n) {
16605 var actual = lodashStable.map(props, function(key) {
17052 expected = lodashStable.map(values, lodashStable.constant(' abc '));
17054 var actual = lodashStable.map(values, function(value, index) {
17072 expected = lodashStable.map(values, stubTrue);
17074 var actual = lodashStable.map(values, function(value) {
17093 expected = lodashStable.map(values, lodashStable.constant('abc '));
17095 var actual = lodashStable.map(values, function(value, index) {
17112 expected = lodashStable.map(values, stubTrue);
17114 var actual = lodashStable.map(values, function(value) {
17133 expected = lodashStable.map(values, lodashStable.constant(' abc'));
17135 var actual = lodashStable.map(values, function(value, index) {
17152 expected = lodashStable.map(values, stubTrue);
17154 var actual = lodashStable.map(values, function(value) {
17211 expected = lodashStable.map(values, lodashStable.constant(string));
17213 var actual = lodashStable.map(values, function(value) {
17231 var actual = lodashStable.map(expected, function(radix) {
17309 var strings = lodashStable.map(['6', '08', '10'], Object),
17310 actual = lodashStable.map(strings, _.parseInt);
17314 actual = lodashStable.map('123', _.parseInt);
17703 expected = lodashStable.map(values, lodashStable.constant([[1, 1], [0]]));
17705 var actual = lodashStable.map(values, function(value, index) {
17883 var actual = lodashStable.map(props, function(key) {
17991 var actual = lodashStable.map(props, function(key) {
18010 var actual = lodashStable.map(paths, function(path) {
18034 expected = lodashStable.map(values, noop);
18039 var actual = lodashStable.map(values, function(value, index) {
18051 expected = lodashStable.map(values, noop);
18056 var actual = lodashStable.map(values, function(value, index) {
18136 var actual = lodashStable.map(props, function(key) {
18155 var actual = lodashStable.map(paths, function(path) {
18179 expected = lodashStable.map(values, noop);
18182 var actual = lodashStable.map(values, function(value, index) {
18195 expected = lodashStable.map(values, noop);
18198 var actual = lodashStable.map(values, function(value, index) {
18419 var expected = lodashStable.map(values, stubOne),
18424 expected = lodashStable.map(values, noop);
18435 var actual = lodashStable.map(props, function(key) {
18466 expected = lodashStable.map(values, lodashStable.constant(Array(4)));
18468 var actual = lodashStable.map(values, function(array) {
18488 var actual = lodashStable.uniq(lodashStable.map(array, function() {
18526 var actual = lodashStable.uniq(lodashStable.map(array, function() {
18589 expected = lodashStable.map(array, stubTrue),
18590 randoms = lodashStable.map(array, _.random);
18592 var actual = lodashStable.map(randoms, function(result, index) {
18692 expected = lodashStable.map([[0], [0, 1], [0, 1, 2]], resolve);
18695 var actual = lodashStable.map(collection, func);
18738 var expected = lodashStable.map(values, lodashStable.constant([undefined, 'b', 'c']));
18740 var actual = lodashStable.map(values, function(value) {
18936 expected = lodashStable.map(empties, noop);
18950 var expected = lodashStable.map(empties, lodashStable.constant('x'));
18952 var actual = lodashStable.map(empties, function(value) {
19088 var actual = _(array).slice(1).map(square)[methodName](predicate).value();
19089 … assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
19105 expected = [1, 0, lodashStable.map(array.slice(1), square)];
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() {
19261 var expected = lodashStable.map(falsey, function(value) {
19265 var actual = lodashStable.map(falsey, function(n, index) {
19297 var actual = lodashStable.map(['a', 'b', 'c'], _.repeat);
19380 var actual = lodashStable.map(props, function(key) {
19472 expected = lodashStable.map(values, noop),
19476 var actual = lodashStable.map(values, function(value) {
19521 expected = lodashStable.map(values, function(value) { return [value, value]; });
19524 var actual = lodashStable.map(values, function(value) {
19566 expected = lodashStable.map(values, lodashStable.constant([[1, 2, 3, 4]]));
19568 var actual = lodashStable.map(values, function(value) {
19671 var wrapped = _(array).slice(1).map(String).reverse(),
19804 var actual = lodashStable.map(values, function(args) {
19819 var expected = lodashStable.map(results, stubFalse),
19820 actual = lodashStable.map(results, lodashStable.isNaN);
19952 var expected = lodashStable.map(empties, noop);
20000 var expected = lodashStable.map(falsey, function(value) {
20004 var actual = lodashStable.map(falsey, function(size, index) {
20038 var expected = lodashStable.map(empties, stubArray);
20062 var actual = lodashStable.map([['a']], _.sampleSize);
20118 expected = lodashStable.map(props, lodashStable.constant(value));
20120 var actual = lodashStable.map(props, function(key) {
20239 var actual = lodashStable.map(values, function(value) {
20351 var expected = lodashStable.map(falsey, stubZero);
20353 var actual = lodashStable.map(falsey, function(object, index) {
20383 lodashStable.each([new Map, realm.map], function(map) { argument
20384 map.set('a', 1);
20385 map.set('b', 2);
20386 assert.strictEqual(_.size(map), 2);
20387 map.clear();
20463 var expected = lodashStable.map(falsey, lodashStable.constant(array));
20465 var actual = lodashStable.map(falsey, function(start) {
20511 var expected = lodashStable.map(falsey, function(value) {
20515 var actual = lodashStable.map(falsey, function(end, index) {
20541 var actual = lodashStable.map(positions, function(pos) {
20552 actual = lodashStable.map(array, _.slice);
20613 var expected = lodashStable.map(empties, stubFalse);
20615 var actual = lodashStable.map(empties, function(value) {
20648 expected = lodashStable.map(values, stubFalse);
20650 var actual = lodashStable.map(values, function(value, index) {
20657 expected = lodashStable.map(values, stubTrue);
20658 actual = lodashStable.map(values, function(value, index) {
20685 var actual = lodashStable.map([[1]], _.some);
20705 var actual = lodashStable.map(_.sortBy(objects, function(object) {
20717 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3]));
20719 var actual = lodashStable.map(values, function(value, index) {
20729 var actual = lodashStable.map(_.sortBy(objects.concat(undefined), 'b'), 'b');
20777 var actual = lodashStable.map([[2, 1, 3], [3, 2, 1]], _.sortBy);
20863 var expected = lodashStable.map(funcs, lodashStable.constant(
20869 var actual = lodashStable.map(funcs, function(func) {
20893 var actual = lodashStable.map(values, function(value) {
20907 var actual = lodashStable.map(values, function(value) {
20918 expected = lodashStable.map(values, lodashStable.constant([0, 0, 0]));
20920 var actual = lodashStable.map(values, function(array) {
21079 expected = lodashStable.map(values, lodashStable.constant(['']));
21081 var actual = lodashStable.map(values, function(value, index) {
21092 actual = lodashStable.map(strings, _.split);
21133 expected = lodashStable.map(falsey, stubTrue);
21135 var actual = lodashStable.map(falsey, function(array, index) {
21158 expected = lodashStable.map(values, lodashStable.constant([1, 2]));
21160 var actual = lodashStable.map(values, function(value) {
21229 var expected = lodashStable.map(falsey, stubTrue);
21231 var actual = lodashStable.map(falsey, function(position) {
21316 expected = lodashStable.map(values, lodashStable.constant(pair[0]));
21321 var actual = lodashStable.map(values, function(value, index) {
21382 var actual = lodashStable.map(values, function(value) {
21491 var expected = lodashStable.map(empties, stubZero);
21493 var actual = lodashStable.map(empties, function(value) {
21529 var expected = lodashStable.map(falsey, stubArray);
21531 var actual = lodashStable.map(falsey, function(array, index) {
21556 actual = lodashStable.map(array, _.tail);
21601 actual = _(array).slice(0, 1).tail().map(iteratee).value();
21607 actual = _(array).filter().slice(0, 1).tail().map(iteratee).value();
21634 var expected = lodashStable.map(falsey, function(value) {
21638 var actual = lodashStable.map(falsey, function(n) {
21665 actual = lodashStable.map(array, _.take);
21716 var expected = lodashStable.map(falsey, function(value) {
21720 var actual = lodashStable.map(falsey, function(n) {
21747 actual = lodashStable.map(array, _.takeRight);
21863 lodashStable.map(array.slice(1), square)
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() {
21997 expected = [1, 0, lodashStable.map(array.slice(1), square)];
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() {
22091 … expected = lodashStable.map(strings, lodashStable.constant('<p>&<>"'/</p>')),
22094 var actual = lodashStable.map(strings, function(string) {
22146 expected = lodashStable.map(strings, lodashStable.constant('ABC')),
22149 var actual = lodashStable.map(strings, function(string) {
22484 expected = lodashStable.map(values, stubString),
22487 var actual = lodashStable.map(values, function(value, index) {
22558 expected = lodashStable.map(values, stubTrue);
22560 var actual = lodashStable.map(values, function(value) {
22590 var expected = lodashStable.map(values, stubFalse);
22592 var actual = lodashStable.map(values, function(value) {
22603 compiles = lodashStable.map(array, _.template),
22606 var actual = lodashStable.map(compiles, function(compiled) {
22694 var actual = lodashStable.map([string, string, string], _.truncate),
23028 args = lodashStable.map(['a', 'b', 'c'], function(chr) { return [{}, chr]; }),
23207 expected = lodashStable.map(values, lodashStable.constant([0, 1, 2]));
23209 var actual = lodashStable.map(values, function(value, index) {
23226 expected = lodashStable.map(values, stubArray);
23228 var actual = lodashStable.map(values, function(value, index) {
23287 var map = new Map;
23288 map.set('a', 1);
23289 map.set('b', 2);
23290 assert.deepEqual(_.toArray(map), [['a', 1], ['b', 2]]);
23315 var actual = _(array).slice(1).map(String).toArray().value();
23316 assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
23318 actual = _(object).toArray().slice(1).map(String).value();
23319 assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String));
23479 var others = lodashStable.map(values, index ? Object : identity);
23481 var actual = lodashStable.map(others, function(value) {
23515 var expected = lodashStable.map(values, function(value) {
23519 var actual = lodashStable.map(values, func);
23529 var expected = lodashStable.map(values, function(value) {
23548 var actual = lodashStable.map(values, function(value) {
23567 var expected = lodashStable.map(values, function(value) {
23587 var actual = lodashStable.map(values, function(value) {
23603 var expected = lodashStable.map(numbers, function(n) {
23607 var actual = lodashStable.map(values, function(value) {
23623 var expected = lodashStable.map(values, function(n) {
23627 var actual = lodashStable.map(values, function(value) {
23643 expected = lodashStable.map(values, lodashStable.constant(isToNumber ? NaN : 0));
23646 var actual = lodashStable.map(values, func);
23660 var expected = lodashStable.map(values, function(value) {
23664 var actual = lodashStable.map(values, function(value, index) {
23717 var actual = lodashStable.map(values, func);
23791 var map = new Map;
23792 map.set('a', 1);
23793 map.set('b', 2);
23794 assert.deepEqual(func(map), [['a', 1], ['b', 2]]);
23842 lodashStable.each([array, lodashStable.map(array, Object)], function(value) {
23951 expected = lodashStable.map(values, stubString);
23953 var actual = lodashStable.map(values, function(value, index) {
23965 actual = lodashStable.map(values, _.toString);
24036 expected = lodashStable.map(accumulators, stubTrue);
24046 var results = lodashStable.map(accumulators, mapper);
24048 var actual = lodashStable.map(results, function(result) {
24054 expected = lodashStable.map(accumulators, lodashStable.constant({ 'a': 1, 'b': 4, 'c': 9 }));
24055 actual = lodashStable.map(results, lodashStable.toPlainObject);
24060 actual = lodashStable.map(accumulators, mapper);
24065 expected = lodashStable.map(accumulators, lodashStable.constant([1, 4, 9]));
24066 actual = lodashStable.map(accumulators, mapper);
24074 var expected = lodashStable.map(typedArrays, stubTrue);
24076 var actual = lodashStable.map(typedArrays, function(type) {
24090 expected = lodashStable.map(values, lodashStable.constant([1, 4, 9]));
24092 var actual = lodashStable.map(values, function(value) {
24103 actual = lodashStable.map(values, function(value) {
24112 var actual = lodashStable.map(values, function(value) {
24145 expected = lodashStable.map(values, stubObject);
24147 var results = lodashStable.map(values, function(value) {
24153 expected = lodashStable.map(values, stubFalse);
24155 var actual = lodashStable.map(results, function(value, index) {
24173 var expected = lodashStable.map(falsey, stubObject);
24175 var actual = lodashStable.map(falsey, function(object, index) {
24214 var expected = lodashStable.map(objects, stubTrue);
24216 var actual = lodashStable.map(objects, function(object) {
24311 actual = lodashStable.map([string, string, string], func);
24422 var values = lodashStable.map(comboMarks, function(mark) {
24426 var expected = lodashStable.map(values, function(value) {
24430 var actual = lodashStable.map(values, function(value) {
24440 var values = lodashStable.map(fitzModifiers, function(modifier) {
24444 var expected = lodashStable.map(values, function(value) {
24448 var actual = lodashStable.map(values, function(value) {
24482 var values = lodashStable.map(fitzModifiers, function(modifier) {
24486 var expected = lodashStable.map(values, function(value) {
24490 var actual = lodashStable.map(values, function(value) {
24528 var actual = lodashStable.map(['6', '8', '10'], _.unary(parseInt));
24731 var actual = lodashStable.map(func([-0, 0]), lodashStable.toString);
24764 var actual = lodashStable.map(func(largeArray), lodashStable.toString);
24810 expected = lodashStable.map(expected, function(symbol) {
24853 actual = lodashStable.map(array, lodashStable.uniq);
24963 expected = lodashStable.map(arrays, lodashStable.constant(['-0']));
24965 var actual = lodashStable.map(arrays, function(array) {
24966 return lodashStable.map(_.uniqWith(array, lodashStable.eq), lodashStable.toString);
25021 expected = lodashStable.map(props, lodashStable.constant([true, false]));
25023 var actual = lodashStable.map(props, function(key) {
25089 var actual = lodashStable.map(values, function(value) {
25181 expected = lodashStable.map(values, lodashStable.constant(_.unzip(array)));
25183 var actual = lodashStable.map(values, function(value, index) {
25312 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3]));
25314 var actual = lodashStable.map(values, function(value) {
25361 var expected = lodashStable.map(burredLetters, function(letter) {
25365 var actual = lodashStable.map(burredLetters, function(letter) {
25411 var actual = lodashStable.map(postfixes, function(postfix) {
25416 var expected = lodashStable.map(postfixes, function(postfix) {
25418 return lodashStable.map(words, function(word) {
25434 var expected = lodashStable.map(ordinals, function(ordinal) {
25438 var actual = lodashStable.map(expected, function(words) {
25450 expected = lodashStable.map(operators, stubArray),
25451 actual = lodashStable.map(operators, _.words);
25465 var expected = lodashStable.map(marks, stubArray),
25466 actual = lodashStable.map(marks, _.words);
25474 var strings = lodashStable.map(['a', 'b', 'c'], Object),
25475 actual = lodashStable.map(strings, _.words);
25529 expected = lodashStable.map(values, stubA);
25531 var actual = lodashStable.map(values, function(value, index) {
25636 var actual = lodashStable.map(['head', 'last'], function(methodName) {
25734 props = lodashStable.map(values, function(value) { return 'key' + value; }),
25735 actual = _(props)[methodName](values).map(square).filter(isEven).take().value();
25737 assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
25788 expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2)));
25790 var actual = lodashStable.map(values, function(value, index) {
25855 var expected = lodashStable.map(falsey, stubArray);
25857 var actual = lodashStable.map(falsey, function(value) {
26026 wrapped1 = _(array1).thru(_.compact).map(square).takeRight(2).sort(),
26043 wrapped1 = _(array1).chain().map(square),
26059 wrapped1 = _(array1).map(square);
26102 var expected = lodashStable.map(falsey, stubTrue);
26104 var actual = lodashStable.map(falsey, function(value, index) {
26144 var expected = lodashStable.map(falsey, stubTrue);
26146 var actual = lodashStable.map(falsey, function(value, index) {
26190 var expected = lodashStable.map(falsey, stubTrue);
26192 var actual = lodashStable.map(falsey, function(value, index) {
26232 var expected = lodashStable.map(falsey, stubTrue);
26234 var actual = lodashStable.map(falsey, function(value, index) {
26278 var expected = lodashStable.map(falsey, stubTrue);
26280 var actual = lodashStable.map(falsey, function(value, index) {
26320 var expected = lodashStable.map(falsey, stubTrue);
26322 var actual = lodashStable.map(falsey, function(value, index) {
26721 expected = lodashStable.map(values, stubString);
26723 var actual = lodashStable.map(values, function(value, index) {
26827 var arrays = lodashStable.map(falsey, stubArray);
26833 var actual = lodashStable.map(falsey, function(value, index) {
26887 var expected = lodashStable.map(falsey, stubTrue),
26890 var actual = lodashStable.map(falsey, function(value, index) {