Lines Matching refs:lodashStable
333 var lodashStable = root.lodashStable; variable
334 if (!lodashStable) {
336 lodashStable = interopRequire('../node_modules/lodash/lodash.js');
341 lodashStable = lodashStable.noConflict();
349 var MapCache = (_.memoize || lodashStable.memoize).Cache;
354 (_.isMatchWith || lodashStable.isMatchWith)({ 'a': 1 }, { 'a': 1 }, function() {
355 var stack = lodashStable.last(arguments);
363 …var coverage = root.__coverage__ || root[lodashStable.find(lodashStable.keys(root), function(key) {
368 var asyncFunc = lodashStable.attempt(function() {
373 var genFunc = lodashStable.attempt(function() {
384 var whitespace = lodashStable.filter([
410 CustomError.prototype = lodashStable.create(Error.prototype, {
421 lodashStable.forOwn(object, function(value, key, object) {
524 return lodashStable.constant(nativeString.replace(reToString, funcName));
530 var result = lodashStable.has(this, 'toString') ? this.toString() : fnToString.call(this);
630 lodashStable.attempt(function() {
631 lodashStable.assign(realm, require('vm').runInNewContext([
672 lodashStable.attempt(function() {
730 lodashStable.attempt(function() {
740 lodashStable.attempt(function() {
745 lodashStable.each([
780 if (amd && lodashStable.includes(ui.loaderPath, 'requirejs')) {
850 largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object));
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) {
1056 lodashStable.times(LARGE_ARRAY_SIZE - length, function() {
1069 lodashStable.forOwn(createCaches(pairs), function(cache, kind) {
1075 lodashStable.each(keys, function(key, index) {
1090 assert.ok(lodashStable.every(keys, function(key) {
1096 lodashStable.forOwn(createCaches(), function(cache, kind) {
1100 lodashStable.each(keys, function(key) {
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) {
1195 lodashStable.times(times, _.after(n, function() { count++; }));
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),
1354 lodashStable.each(['assign', 'assignIn'], function(methodName) {
1402 'toString': lodashStable.constant('source')
1405 defineProperty(object, 'a', lodashStable.assign({}, descriptor, {
1409 defineProperty(object, 'b', lodashStable.assign({}, descriptor, {
1413 defineProperty(object, 'c', lodashStable.assign({}, descriptor, {
1417 defineProperty(object, 'constructor', lodashStable.assign({}, descriptor, {
1418 'get': lodashStable.constant(Object)
1469 lodashStable.each(['assignWith', 'assignInWith'], function(methodName) {
1515 var values = lodashStable.reject(empties, function(value) {
1516 return (value === 0) || lodashStable.isArray(value);
1519 var array = lodashStable.transform(values, function(result, value) {
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) {
1594 var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
1597 lodashStable.each([[2], ['2'], [2, 1]], function(paths) {
1598 lodashStable.times(2, function(index) {
1615 var array = lodashStable.range(LARGE_ARRAY_SIZE),
1620 lodashStable.each([lastIndex, lastIndex + '', LARGE_ARRAY_SIZE, []], function(n, index) {
1663 assert.strictEqual(_.attempt(lodashStable.constant('x')), 'x');
1676 var expected = lodashStable.map(errors, stubTrue);
1678 var actual = lodashStable.map(errors, function(error) {
1689 assert.ok(lodashStable.isEqual(actual, Error('x')));
1703 var expected = lodashStable.map(realm.errors, stubTrue);
1705 var actual = lodashStable.map(realm.errors, function(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++; }));
1800 var values = lodashStable.reject(falsey.slice(1), function(value) { return value == null; }),
1801 expected = lodashStable.map(values, function(value) { return [value]; });
1803 var actual = lodashStable.map(values, function(value) {
1810 assert.ok(lodashStable.every(actual, function(value, index) {
1811 return lodashStable.isEqual(value, expected[index]);
1824 lodashStable.times(2, function(index) {
1919 expected = lodashStable.times(count, lodashStable.constant([undefined, undefined]));
1921 var actual = lodashStable.times(count, function(index) {
2003 var createCtor = lodashStable.attempt(Function, '"use strict";return class A{}');
2008 expected = lodashStable.times(count, stubTrue);
2010 var actual = lodashStable.times(count, function(index) {
2075 var object = lodashStable.cloneDeep(source);
2078 var actual = lodashStable.map(['a', 'b', 'c'], function(key) {
2088 var object = lodashStable.cloneDeep(source);
2091 var actual = lodashStable.map(['a', 'b', 'c', 'd'], function(key) {
2103 var actual = lodashStable.map(props, function(key) {
2104 var object = lodashStable.cloneDeep(source);
2106 return object[lodashStable.toString(key)].call({});
2123 var object = lodashStable.cloneDeep(source);
2126 var actual = lodashStable.map(args, function(key) {
2218 lodashStable.each(['camel', 'kebab', 'lower', 'snake', 'start', 'upper'], function(caseName) {
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) {
2266 letter = letter == 'IJ' ? letter : lodashStable.capitalize(letter);
2275 assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue));
2283 lodashStable.each(["'", '\u2019'], function(apos) {
2284 var actual = lodashStable.map(postfixes, function(postfix) {
2288 var expected = lodashStable.map(postfixes, function(postfix) {
2306 var actual = lodashStable.map(['\xd7', '\xf7'], func);
2315 assert.strictEqual(func({ 'toString': lodashStable.constant(string) }), converted);
2347 var actual = lodashStable.reduce(funcs, function(result, func) {
2374 lodashStable.each(['safe HTML', 'safeHTML'], function(string) {
2378 lodashStable.each(['escape HTML entities', 'escapeHTMLEntities'], function(string) {
2382 lodashStable.each(['XMLHttpRequest', 'XmlHTTPRequest'], function(string) {
2411 expected = lodashStable.map(values, function(value) { return [value]; }),
2412 actual = lodashStable.map(values, _.castArray);
2485 lodashStable.times(2, function(index) {
2557 var expected = lodashStable.map(falsey, function(value) {
2561 var actual = lodashStable.map(falsey, function(size, index) {
2571 var values = lodashStable.reject(falsey, lodashStable.isUndefined).concat(-1, -Infinity),
2572 expected = lodashStable.map(values, stubArray);
2574 var actual = lodashStable.map(values, function(n) {
2590 var actual = lodashStable.map([[1, 2], [3, 4]], _.chunk);
2730 lodashStable.each(errors, function(error) {
2763 lodashStable.times(LARGE_ARRAY_SIZE + 1, function(index) {
2789 lodashStable.each(['clone', 'cloneDeep'], function(methodName) {
2793 lodashStable.forOwn(objects, function(object, kind) {
2798 assert.ok(lodashStable.isEqual(actual, object));
2800 if (lodashStable.isObject(object)) {
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) {
3019 var objects = lodashStable.transform(_, function(result, value, key) {
3020 if (lodashStable.startsWith(key, '_') && lodashStable.isObject(value) &&
3021 !lodashStable.isArguments(value) && !lodashStable.isElement(value) &&
3022 !lodashStable.isFunction(value)) {
3023 props.push(lodashStable.capitalize(lodashStable.camelCase(key)));
3028 var expected = lodashStable.map(objects, stubTrue);
3030 var actual = lodashStable.map(objects, function(object) {
3044 actual = lodashStable.map(expected, func);
3070 lodashStable.each(arrayViews, function(type) {
3076 lodashStable.times(2, function(index) {
3095 lodashStable.forOwn(uncloneable, function(value, key) {
3115 lodashStable.each(['cloneWith', 'cloneDeepWith'], function(methodName) {
3142 lodashStable.forOwn(uncloneable, function(value, key) {
3147 return lodashStable.isPlainObject(value) ? undefined : value;
3168 var largeArray = lodashStable.range(LARGE_ARRAY_SIZE).concat(null);
3215 pass = lodashStable.isEqual(actual, _.compact(_.slice(largeArray, 1)));
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) {
3317 [lodashStable.matches({ 'a': 1 }), stubA],
3318 [lodashStable.matchesProperty('b', 1), stubB],
3319 [lodashStable.property('c'), stubC]
3369 lodashStable.each([false, true], function(value) {
3409 lodashStable.each(['conforms', 'conformsTo'], function(methodName) {
3431 var actual = lodashStable.filter(objects, par);
3439 actual = lodashStable.filter(objects, par);
3462 actual = lodashStable.filter(objects, par);
3504 actual = lodashStable.filter(objects, conforms(Foo));
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) {
3593 assert.ok(lodashStable.every(results, function(result) {
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) {
3696 var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
3697 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
3698 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
3770 assert.deepEqual(lodashStable.keys(object), ['a']);
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) {
3791 return lodashStable.isPlainObject(index ? _.create(value) : _.create());
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) {
3907 lodashStable.times(2, function(index) {
4005 expected = lodashStable.map(values, stubArray);
4007 var actual = lodashStable.map(values, function(arity) {
4066 lodashStable.times(2, function(index) {
4133 lodashStable.each(['curry', 'curryRight'], function(methodName) {
4172 lodashStable.each([array, object], function(collection) {
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) {
4588 var expected = lodashStable.clone(source);
4591 expected = lodashStable.clone(object);
4668 expected = lodashStable.cloneDeep(source),
4736 var expected = lodashStable.map(falsey, function(value) {
4740 var actual = lodashStable.map(falsey, function(value) {
4896 lodashStable.each(['difference', 'differenceBy', 'differenceWith'], function(methodName) {
4918 var actual = lodashStable.map(array, function(value) {
4924 actual = lodashStable.map(func([-0, 1], [1]), lodashStable.toString);
4937 var array1 = lodashStable.range(LARGE_ARRAY_SIZE + 1),
4938 array2 = lodashStable.range(LARGE_ARRAY_SIZE),
4954 var actual = lodashStable.map(array, function(value) {
4955 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(value));
4961 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne);
4962 actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString);
4969 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN);
4978 largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object1));
5031 actual = _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], lodashStable.isEqual);
5040 largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne),
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) {
5103 lodashStable.each([0, -1, -Infinity], function(n) {
5111 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
5126 actual = lodashStable.map(array, _.drop);
5135 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
5177 var expected = lodashStable.map(falsey, function(value) {
5181 var actual = lodashStable.map(falsey, function(n) {
5191 lodashStable.each([0, -1, -Infinity], function(n) {
5199 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
5214 actual = lodashStable.map(array, _.dropRight);
5223 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
5376 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3),
5394 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3);
5438 lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
5446 var expected = lodashStable.map(falsey, stubTrue);
5448 var actual = lodashStable.map(falsey, function(position) {
5458 lodashStable.each([-1, -3, -Infinity], function(position) {
5459 assert.ok(lodashStable.every(string, function(chr) {
5527 lodashStable.each(['`', '/'], function(chr) {
5560 expected = lodashStable.map(values, stubString);
5562 var actual = lodashStable.map(values, function(value, index) {
5578 assert.strictEqual(lodashStable.every([true, 1, 'a'], identity), true);
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);
5664 …lodashStable.each(['assign', 'assignIn', 'bindAll', 'defaults', 'defaultsDeep', 'merge'], function…
5702 assert.ok(lodashStable.every(actual, function(value, index) {
5717 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
5726 var expected = lodashStable.map(falsey, lodashStable.constant(['a', 'a', 'a']));
5728 var actual = lodashStable.map(falsey, function(start) {
5746 lodashStable.each([-3, -4, -Infinity], function(start) {
5755 lodashStable.each([2, 3], function(start) {
5771 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
5780 var expected = lodashStable.map(falsey, function(value) {
5784 var actual = lodashStable.map(falsey, function(end) {
5802 lodashStable.each([-3, -4, -Infinity], function(end) {
5813 var actual = lodashStable.map(positions, function(pos) {
5825 actual = lodashStable.map(array, _.fill);
5864 …lodashStable.each(['find', 'findIndex', 'findKey', 'findLast', 'findLastIndex', 'findLastKey'], fu…
5918 …var emptyValues = lodashStable.endsWith(methodName, 'Index') ? lodashStable.reject(empties, lodash…
5919 expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1]));
5921 var actual = lodashStable.map(emptyValues, function(value) {
5977 var largeArray = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
5980 lodashStable.times(2, function(index) {
5984 assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven)));
6048 lodashStable.each(['find', 'findLast'], function(methodName) {
6057 array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
6076 lodashStable.each(['includes', 'find'], function(methodName) {
6079 resolve = methodName == 'find' ? lodashStable.curry(lodashStable.eq) : identity;
6081 lodashStable.each({
6086 var values = lodashStable.toArray(collection);
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) {
6190 lodashStable.each(['findIndex', 'indexOf'], function(methodName) {
6193 resolve = methodName == 'findIndex' ? lodashStable.curry(lodashStable.eq) : identity;
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) {
6267 var resolve = lodashStable.curry(lodashStable.eq);
6269 lodashStable.each({
6274 var values = lodashStable.toArray(collection);
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) {
6419 lodashStable.each([-1, 0], function(depth) {
6435 lodashStable.each(['flatMap', 'flatMapDeep', 'flatMapDepth'], function(methodName) {
6447 expected = lodashStable.flatten(lodashStable.map(array, duplicate));
6477 expected = lodashStable.map(values, lodashStable.constant([1, 2, 3, 4]));
6479 lodashStable.each([array, object], function(collection) {
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) {
6532 lodashStable.each([-1, 0], function(depth) {
6570 lodashStable.each(methodNames, function(methodName) {
6583 expected = lodashStable.map(methodNames, lodashStable.constant(['a']));
6587 var actual = lodashStable.map(methodNames, function(methodName) {
6601 lodashStable.times(3, function(index) {
6676 lodashStable.each(['flow', 'flowRight'], function(methodName) {
6727 array = lodashStable.range(LARGE_ARRAY_SIZE),
6731 lodashStable.times(2, function(index) {
6819 lodashStable.each(['forIn', 'forInRight'], function(methodName) {
6840 lodashStable.each(['forOwn', 'forOwnRight'], function(methodName) {
6978 lodashStable.each(methods, function(methodName) {
6997 if (lodashStable.includes(rightMethods, methodName)) {
7001 if (lodashStable.includes(objectMethods, methodName)) {
7021 var expected = lodashStable.includes(objectMethods, methodName)
7026 expected = lodashStable.map(expected, function(args) {
7030 else if (lodashStable.includes(objectMethods, methodName)) {
7031 expected = lodashStable.map(expected, function(args) {
7036 if (lodashStable.includes(rightMethods, methodName)) {
7053 lodashStable.each(lodashStable.difference(methods, objectMethods), function(methodName) {
7070 assert.notOk(lodashStable.includes(keys, 'a'));
7078 lodashStable.each(lodashStable.difference(methods, unwrappedMethods), function(methodName) {
7095 lodashStable.each(unwrappedMethods, function(methodName) {
7126 …lodashStable.each(lodashStable.difference(methods, arrayMethods, forInMethods), function(methodNam…
7148 lodashStable.each(iterationMethods, function(methodName) {
7164 lodashStable.each(collectionMethods, function(methodName) {
7178 expected = lodashStable.map(values, stubTrue);
7180 var actual = lodashStable.map(values, function(length) {
7197 lodashStable.each(methods, function(methodName) {
7225 …lodashStable.each(lodashStable.difference(lodashStable.union(methods, collectionMethods), arrayMet…
7258 …lodashStable.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName…
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) {
7319 return object !== source && lodashStable.isEqual(object, source);
7324 actual = lodashStable.map(values, function(value) {
7325 return lodashStable.isEqual(func(value), {});
7342 assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected);
7343 assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected);
7361 lodashStable.each(['assign', 'assignIn', 'merge'], function(methodName) {
7375 …lodashStable.each(['assign', 'assignIn', 'assignInWith', 'assignWith', 'defaults', 'defaultsDeep',…
7381 lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
7388 'get': lodashStable.constant(value),
7398 lodashStable.each(['assignWith', 'assignInWith', 'mergeWith'], function(methodName) {
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));
7463 …lodashStable.each(['_baseEach', 'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOw…
7474 values.push(lodashStable.isArray(value) ? other : value);
7478 assert.deepEqual(values, [lodashStable.endsWith(methodName, 'Right') ? 3 : 1]);
7493 values.push(lodashStable.isArray(value) ? other : value);
7517 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(count) {
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) {
7646 var array = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
7706 expected = lodashStable.map(values, lodashStable.constant({ '4': [4], '6': [6, 6] }));
7708 var actual = lodashStable.map(values, function(value, index) {
7757 var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
7758 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
7759 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
7766 …assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))…
7822 lodashStable.each(['has', 'hasIn'], function(methodName) {
7837 lodashStable.each(['a', ['a']], function(path) {
7854 lodashStable.each(['a.b', ['a', 'b']], function(path) {
7858 lodashStable.each(['a.a', ['a', 'a']], function(path) {
7867 fn.toString = lodashStable.constant('fn');
7871 expected = lodashStable.map(paths, stubTrue);
7873 lodashStable.times(2, function(index) {
7874 var actual = lodashStable.map(paths, function(path) {
7893 lodashStable.each([1, [1]], function(path) {
7903 expected = lodashStable.map(props, stubTrue);
7905 var actual = lodashStable.map(props, function(key) {
7942 lodashStable.each(['a.b', ['a.b']], function(path) {
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) {
7981 lodashStable.each(['a', ['a']], function(path) {
7992 lodashStable.each(['a.b', ['a', 'b']], function(path) {
8001 expected = lodashStable.map(values, stubFalse);
8003 lodashStable.each(['constructor', ['constructor']], function(path) {
8004 var actual = lodashStable.map(values, function(value) {
8016 expected = lodashStable.map(values, stubFalse);
8018 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
8019 var actual = lodashStable.map(values, function(value) {
8031 expected = lodashStable.map(values, stubFalse);
8033 lodashStable.each(['a.b', ['a', 'b']], function(path) {
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);
8138 var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
8141 lodashStable.each(['head', 'first'], function(methodName) {
8142 lodashStable.times(2, function(index) {
8174 lodashStable.each({
8222 lodashStable.each({
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) {
8290 assert.ok(lodashStable.every(values, lodashStable.partial(_.includes, array)));
8304 var expected = lodashStable.map(falsey, stubArray);
8306 var actual = lodashStable.map(falsey, function(array, index) {
8331 actual = lodashStable.map(array, _.initial);
8340 var array = lodashStable.range(LARGE_ARRAY_SIZE),
8361 assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven)));
8395 lodashStable.each(falsey, function(value, index) {
8432 assert.deepEqual(actual, lodashStable.map(actual, stubTrue));
8440 lodashStable.each(['intersection', 'intersectionBy', 'intersectionWith'], function(methodName) {
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) {
8508 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(value));
8509 return lodashStable.map(func(values, largeArray), lodashStable.toString);
8518 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN);
8526 largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object));
8529 assert.deepEqual(func(lodashStable.range(LARGE_ARRAY_SIZE), [1]), [1]);
8593 actual = _.intersectionWith(objects, others, lodashStable.isEqual);
8602 largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubZero),
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) {
8697 assert.ok(lodashStable.isEqual(_.invertBy(object), expected));
8723 var object = { 'a': lodashStable.constant('A') },
8742 expected = lodashStable.map(values, noop);
8744 var actual = lodashStable.map(values, function(value) {
8759 var actual = lodashStable.map(props, function(key) {
8771 lodashStable.each(['a.b', ['a', 'b']], function(path) {
8782 lodashStable.each(['a.b', ['a', 'b']], function(path) {
8877 var objects = lodashStable.map([null, undefined, stubOne], function(value) {
8881 var expected = lodashStable.map(objects, function(object) {
8897 lodashStable.each(['a.b', ['a', 'b']], function(path) {
8932 var array = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
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) {
9471 lodashStable.each([new Set, realm.set], function(set) {
9553 var expected = lodashStable.map(pairs, function(pair) {
9557 var actual = lodashStable.map(pairs, function(pair) {
9961 lodashStable.times(2, function(index) {
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) {
10008 assert.strictEqual(_.isEqual(date, { 'getTime': lodashStable.constant(+date) }), false);
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) {
10105 … lodashStable.each([[promise, Promise.resolve(1)], [promise, realm.promise]], function(promises) {
10132 lodashStable.each([[set, new Set], [set, realm.set]], function(sets) {
10227 lodashStable.each(values, function(vals) {
10273 var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1));
10315 expected = lodashStable.map(values, stubFalse);
10317 var actual = lodashStable.map(values, function(value) {
10420 expected = lodashStable.map(values, stubFalse);
10423 lodashStable.each(values, function(value) {
10424 actual.push(_.isEqualWith('a', 'a', lodashStable.constant(value)));
10435 actual = lodashStable.map([array, [1, 0, 3]], eq);
10459 lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
10462 array = lodashStable.toArray(pair[0]);
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) {
10712 lodashStable.each(['isInteger', 'isSafeInteger'], function(methodName) {
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);
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) {
10930 var expected = lodashStable.map(falsey, stubFalse);
10933 lodashStable.each(falsey, function(value) {
10934 actual.push(_.isMatchWith(object, { 'a': 2 }, lodashStable.constant(value)));
10960 actual = lodashStable.map([object, { 'a': 2 }], matches);
10984 lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) {
10987 array = lodashStable.toArray(pair[0]),
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) {
11565 assert.notOk(lodashStable.has(object, Symbol.toStringTag));
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) {
11851 var props = lodashStable.invokeMap(typedArrays, 'toLowerCase');
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) {
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) {
12061 lodashStable.each(funcs, function(methodName) {
12086 lodashStable.each(funcs, function(methodName) {
12118 … expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object]));
12120 var actual = lodashStable.map(values, function(value, index) {
12145 lodashStable.each(sources, function(source, index) {
12146 var object = lodashStable.cloneDeep(source),
12198 lodashStable.each(sources, function(source, index) {
12199 var object = { 'a': lodashStable.cloneDeep(source) },
12273 iteratees = lodashStable.map(array, _.iteratee),
12274 expected = lodashStable.map(array, stubFalse);
12276 var actual = lodashStable.map(iteratees, function(iteratee) {
12885 expected = lodashStable.map(values, lodashStable.constant({ '4': 4, '6': 6 }));
12887 var actual = lodashStable.map(values, function(value, index) {
12938 var array = lodashStable.range(LARGE_ARRAY_SIZE).concat(
12939 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE),
12940 lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE)
12957 lodashStable.each(['keys', 'keysIn'], function(methodName) {
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);
13221 var largeArray = lodashStable.range(LARGE_ARRAY_SIZE),
13224 lodashStable.times(2, function(index) {
13313 lodashStable.each(['findLastIndex', 'lastIndexOf'], function(methodName) {
13316 resolve = methodName == 'findLastIndex' ? lodashStable.curry(lodashStable.eq) : identity;
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) {
13391 …lodashStable.each(['indexOf', 'lastIndexOf', 'sortedIndexOf', 'sortedLastIndexOf'], function(metho…
13399 var expected = lodashStable.map(falsey, lodashStable.constant(-1));
13401 var actual = lodashStable.map(falsey, function(array, index) {
13501 expected = lodashStable.map(values, lodashStable.constant([1, 2]));
13503 lodashStable.each([array, object], function(collection) {
13504 var actual = lodashStable.map(values, function(value, index) {
13515 var expected = lodashStable.map(falsey, stubArray);
13517 var actual = lodashStable.map(falsey, function(collection, index) {
13572 array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
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) {
13697 return [lodashStable.isEqual(result, object), result === object];
13708 lodashStable.each(['mapKeys', 'mapValues'], function(methodName) {
13727 var expected = lodashStable.map(falsey, stubObject);
13729 var actual = lodashStable.map(falsey, function(object, index) {
13762 lodashStable.each(sources, function(source, index) {
13763 var object = lodashStable.cloneDeep(source),
13787 lodashStable.each(['matches', 'isMatch'], function(methodName) {
13843 actual = lodashStable.map(objects, matches(source)),
13844 expected = lodashStable.map(objects, stubTrue);
13876 var object1 = { 'a': lodashStable.noop },
13905 actual = lodashStable.map(objects, matches(Foo));
13913 function Foo(object) { lodashStable.assign(this, object); }
13925 actual = lodashStable.filter(objects, matches({ 'a': ['d'] }));
13929 actual = lodashStable.filter(objects, matches({ 'a': ['b', 'd'] }));
13932 actual = lodashStable.filter(objects, matches({ 'a': ['d', 'b'] }));
13940 actual = lodashStable.filter(objects, matches({ 'a': [2, 2] }));
13953 var actual = lodashStable.filter(objects, matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] }));
13968 var actual = lodashStable.filter(objects, matches({ 'a': map }));
13973 actual = lodashStable.filter(objects, matches({ 'a': map }));
13978 actual = lodashStable.filter(objects, matches({ 'a': map }));
13998 var actual = lodashStable.filter(objects, matches({ 'a': set }));
14003 actual = lodashStable.filter(objects, matches({ 'a': set }));
14008 actual = lodashStable.filter(objects, matches({ 'a': set }));
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) {
14115 actual = lodashStable.filter(objects, matches({ 'a': [], 'b': {} }));
14155 lodashStable.each(['a.b', ['a', 'b']], function(path) {
14166 lodashStable.each([1, [1]], function(path) {
14180 expected = lodashStable.map(props, lodashStable.constant([true, false]));
14182 var actual = lodashStable.map(props, function(key, index) {
14196 fn.toString = lodashStable.constant('fn');
14200 expected = lodashStable.map(paths, stubTrue);
14202 lodashStable.times(2, function(index) {
14203 var actual = lodashStable.map(paths, function(path) {
14217 lodashStable.each(['a.b', ['a.b']], function(path) {
14227 expected = lodashStable.map(values, stubFalse);
14229 lodashStable.each(['constructor', ['constructor']], function(path) {
14232 var actual = lodashStable.map(values, function(value, index) {
14246 expected = lodashStable.map(values, stubFalse);
14248 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
14251 var actual = lodashStable.map(values, function(value, index) {
14266 lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
14280 lodashStable.each(['a', ['a']], function(path) {
14295 expected = lodashStable.map(objects, stubTrue);
14297 lodashStable.each(['a', ['a']], function(path) {
14298 assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected);
14326 var object1 = { 'a': lodashStable.noop },
14345 actual = lodashStable.map(objects, _.matchesProperty('a', Foo));
14353 function Foo(object) { lodashStable.assign(this, object); }
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 }));
14476 lodashStable.each(['a.b', ['a', 'b']], function(path) {
14481 lodashStable.each(['a.a', ['a', 'a']], function(path) {
14516 var actual = lodashStable.filter(objects, function(object) {
14526 …lodashStable.each([{ 'a': { 'b': 2, 'c': 3 } }, { 'a': 1, 'b': 2 }, { 'a': 1 }], function(source, …
14527 var object = lodashStable.cloneDeep(source),
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);
14655 var entry = lodashStable.find(this.__data__, ['key', key]);
14659 return lodashStable.some(this.__data__, ['key', key]);
14671 ImmutableCache.prototype = lodashStable.create(CustomCache.prototype, {
14728 expected = lodashStable.map(values, stubTrue);
14730 var actual = lodashStable.map(values, function(resolver, index) {
14754 var actual = lodashStable.map(props, function(value) {
14767 lodashStable.times(2, function(index) {
14849 lodashStable.times(MAX_MEMOIZE_SIZE, memoized);
15040 var expected = lodashStable.map(typedArrays, function(type, index) {
15046 var actual = lodashStable.map(typedArrays, function(type) {
15051 assert.ok(lodashStable.isArray(actual));
15054 expected = lodashStable.map(typedArrays, function(type, index) {
15060 actual = lodashStable.map(typedArrays, function(type, index) {
15062 array = lodashStable.range(arrays[index].length);
15068 assert.ok(lodashStable.isArray(actual));
15085 expected = lodashStable.map(values, stubTrue);
15087 var actual = lodashStable.map(values, function(value) {
15102 assert.ok(lodashStable.isBuffer(actual));
15120 expected = lodashStable.map(values, stubTrue);
15122 var actual = lodashStable.map(values, function(value, index) {
15132 lodashStable.isEqual(newValue, value)
15163 lodashStable.assign(this, object);
15246 expected = lodashStable.map(pairs, stubTrue);
15248 var actual = lodashStable.map(pairs, function(pair) {
15287 return lodashStable.isArray(a) ? a.concat(b) : undefined;
15315 return lodashStable.isArray(a) ? a.concat(b) : undefined;
15329 return lodashStable.isArray(a) ? a.concat(b) : undefined;
15346 lodashStable.each(['a', ['a']], function(path) {
15358 lodashStable.each(['a.b', ['a', 'b']], function(path) {
15367 var array = lodashStable.times(3, _.constant);
15369 lodashStable.each([1, [1]], function(path) {
15379 fn.toString = lodashStable.constant('fn');
15385 lodashStable.times(2, function(index) {
15386 var actual = lodashStable.map(paths, function(path) {
15401 lodashStable.each(['a', ['a']], function(path) {
15412 lodashStable.each(['a.b', ['a.b']], function(path) {
15422 expected = lodashStable.map(values, noop);
15424 lodashStable.each(['constructor', ['constructor']], function(path) {
15427 var actual = lodashStable.map(values, function(value, index) {
15439 expected = lodashStable.map(values, noop);
15441 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
15444 var actual = lodashStable.map(values, function(value, index) {
15457 lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
15472 lodashStable.each(['fn', ['fn']], function(path) {
15483 lodashStable.each(['a.b', ['a', 'b']], function(path) {
15500 lodashStable.each(['a', ['a']], function(path) {
15512 lodashStable.each(['a.b', ['a', 'b']], function(path) {
15521 var array = lodashStable.times(3, _.constant);
15523 lodashStable.each([1, [1]], function(path) {
15533 fn.toString = lodashStable.constant('fn');
15539 lodashStable.times(2, function(index) {
15540 var actual = lodashStable.map(paths, function(path) {
15555 lodashStable.each(['a', ['a']], function(path) {
15566 lodashStable.each(['a.b', ['a.b']], function(path) {
15576 expected = lodashStable.map(values, noop);
15578 lodashStable.each(['constructor', ['constructor']], function(path) {
15579 var actual = lodashStable.map(values, function(value, index) {
15592 expected = lodashStable.map(values, noop);
15594 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
15595 var actual = lodashStable.map(values, function(value, index) {
15610 lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
15626 lodashStable.each(['fn', ['fn']], function(path) {
15637 lodashStable.each(['a.b', ['a', 'b']], function(path) {
15658 expected = lodashStable.map(values, noop);
15660 var actual = lodashStable.map(values, function(value, index) {
15680 lodashStable.each(['max', 'maxBy', 'min', 'minBy'], function(methodName) {
15696 var array = lodashStable.range(0, 5e5);
15713 lodashStable.each(['maxBy', 'minBy'], function(methodName) {
15828 var object = lodashStable.create(_);
15888 lodashStable.each([_, Wrapper], function(func) {
15889 lodashStable.each([{ 'chain': false }, { 'chain': true }], function(options) {
15950 lodashStable.each([_, Wrapper], function(func) {
15977 var array = lodashStable.range(LARGE_ARRAY_SIZE),
16045 …expected = lodashStable.map(falsey, lodashStable.constant([objects[3], objects[1], objects[2], obj…
16047 actual = lodashStable.map(falsey, function(order, index) {
16198 expected = lodashStable.times(count, stubTrue);
16200 var actual = lodashStable.times(count, function(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) {
16492 lodashStable.each(['a.b', ['a.b']], function(path) {
16506 lodashStable.each([null, undefined], function(value) {
16535 lodashStable.each(['a', ['a'], 'a.b', ['a.b']], function(path) {
16565 lodashStable.each(['omit', 'omitBy'], function(methodName) {
16569 resolve = lodashStable.nthArg(1);
16573 props = lodashStable.castArray(props);
16575 return lodashStable.some(props, function(key) {
16576 key = lodashStable.isSymbol(key) ? key : lodashStable.toString(key);
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) {
17071 var values = [Object(string), { 'toString': lodashStable.constant(string) }],
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) {
17111 var values = [Object(string), { 'toString': lodashStable.constant(string) }],
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) {
17151 var values = [Object(string), { 'toString': lodashStable.constant(string) }],
17152 expected = lodashStable.map(values, stubTrue);
17154 var actual = lodashStable.map(values, function(value) {
17166 lodashStable.each(['pad', 'padStart', 'padEnd'], function(methodName) {
17182 lodashStable.each([0, -2], function(length) {
17190 lodashStable.each(['', '4'], function(length) {
17199 lodashStable.each([undefined, '_-'], function(chars) {
17211 expected = lodashStable.map(values, lodashStable.constant(string));
17213 var actual = lodashStable.map(values, function(value) {
17229 var expected = lodashStable.range(2, 37);
17231 var actual = lodashStable.map(expected, function(radix) {
17250 lodashStable.each(['0x20', '0X20'], function(string) {
17270 lodashStable.times(2, function(index) {
17275 lodashStable.times(2, function(otherIndex) {
17283 lodashStable.each(['0x20', '0X20'], function(string) {
17309 var strings = lodashStable.map(['6', '08', '10'], Object),
17310 actual = lodashStable.map(strings, _.parseInt);
17314 actual = lodashStable.map('123', _.parseInt);
17323 lodashStable.each(['partial', 'partialRight'], function(methodName) {
17469 return lodashStable.isObject(value) ? _.mergeWith(value, other, deep) : value;
17612 lodashStable.times(2, function(index) {
17623 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17630 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17640 lodashStable.each(['curry', 'curryRight'], function(methodName, index) {
17645 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17651 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17659 lodashStable.each(['partial', 'partialRight'], function(methodName, index) {
17665 var actual = _.last(lodashStable.times(HOT_COUNT, function() {
17672 actual = _.last(lodashStable.times(HOT_COUNT, function() {
17703 expected = lodashStable.map(values, lodashStable.constant([[1, 1], [0]]));
17705 var actual = lodashStable.map(values, function(value, index) {
17778 lodashStable.each(['a.b', ['a.b']], function(path) {
17792 lodashStable.each([null, undefined], function(value) {
17841 lodashStable.each(['pick', 'pickBy'], function(methodName) {
17846 resolve = lodashStable.nthArg(1);
17850 props = lodashStable.castArray(props);
17852 return lodashStable.some(props, function(key) {
17853 key = lodashStable.isSymbol(key) ? key : lodashStable.toString(key);
17883 var actual = lodashStable.map(props, function(key) {
17944 lodashStable.each(['a', ['a']], function(path) {
17956 lodashStable.each(['a.b', ['a', 'b']], function(path) {
17968 lodashStable.each(['a', ['a']], function(path) {
17979 lodashStable.each([1, [1]], function(path) {
17991 var actual = lodashStable.map(props, function(key) {
18003 fn.toString = lodashStable.constant('fn');
18009 lodashStable.times(2, function(index) {
18010 var actual = lodashStable.map(paths, function(path) {
18024 lodashStable.each(['a.b', ['a.b']], function(path) {
18034 expected = lodashStable.map(values, noop);
18036 lodashStable.each(['constructor', ['constructor']], function(path) {
18039 var actual = lodashStable.map(values, function(value, index) {
18051 expected = lodashStable.map(values, noop);
18053 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
18056 var actual = lodashStable.map(values, function(value, index) {
18069 lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
18088 lodashStable.each(['a', ['a']], function(path) {
18099 lodashStable.each(['a.b', ['a', 'b']], function(path) {
18114 lodashStable.each(['b', ['b']], function(path) {
18125 lodashStable.each([1, [1]], function(path) {
18136 var actual = lodashStable.map(props, function(key) {
18148 fn.toString = lodashStable.constant('fn');
18154 lodashStable.times(2, function(index) {
18155 var actual = lodashStable.map(paths, function(path) {
18170 lodashStable.each(['a.b', ['a.b']], function(path) {
18179 expected = lodashStable.map(values, noop);
18181 lodashStable.each(['constructor', ['constructor']], function(path) {
18182 var actual = lodashStable.map(values, function(value, index) {
18195 expected = lodashStable.map(values, noop);
18197 …lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], func…
18198 var actual = lodashStable.map(values, function(value, index) {
18212 lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) {
18274 actual = _.pullAllWith(objects, [{ 'x': 2, 'y': 2 }], lodashStable.isEqual);
18284 lodashStable.each(['pull', 'pullAll', 'pullAllWith'], function(methodName) {
18411 var values = lodashStable.reject(empties, function(value) {
18412 return (value === 0) || lodashStable.isArray(value);
18415 var array = lodashStable.transform(values, function(result, value) {
18419 var expected = lodashStable.map(values, stubOne),
18424 expected = lodashStable.map(values, noop);
18425 actual = lodashStable.at(array, values);
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() {
18501 assert.ok(lodashStable.some(array, function() {
18513 assert.ok(lodashStable.some(array, function() {
18526 var actual = lodashStable.uniq(lodashStable.map(array, function() {
18539 assert.ok(lodashStable.every(array, function() {
18544 assert.ok(lodashStable.some(array, function() {
18589 expected = lodashStable.map(array, stubTrue),
18590 randoms = lodashStable.map(array, _.random);
18592 var actual = lodashStable.map(randoms, function(result, index) {
18604 lodashStable.each(['range', 'rangeRight'], function(methodName) {
18663 lodashStable.each(falsey, function(value, index) {
18692 expected = lodashStable.map([[0], [0, 1], [0, 1, 2]], resolve);
18694 lodashStable.each([array, object], function(collection) {
18695 var actual = lodashStable.map(collection, func);
18734 var values = lodashStable.reject(empties, function(value) {
18735 return (value === 0) || lodashStable.isArray(value);
18738 var expected = lodashStable.map(values, lodashStable.constant([undefined, 'b', 'c']));
18740 var actual = lodashStable.map(values, function(value) {
18888 isFIFO = lodashStable.keys(object)[0] == 'a';
18917 lodashStable.each(['reduce', 'reduceRight'], function(methodName) {
18936 expected = lodashStable.map(empties, noop);
18938 lodashStable.each(empties, function(value) {
18950 var expected = lodashStable.map(empties, lodashStable.constant('x'));
18952 var actual = lodashStable.map(empties, function(value) {
19025 lodashStable.each(['filter', 'reject'], function(methodName) {
19081 var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
19084 var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
19089 … assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate));
19092 assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate));
19104 array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
19105 expected = [1, 0, lodashStable.map(array.slice(1), square)];
19261 var expected = lodashStable.map(falsey, function(value) {
19265 var actual = lodashStable.map(falsey, function(n, index) {
19291 assert.strictEqual(_.repeat({ 'toString': lodashStable.constant('*') }, 3), '***');
19297 var actual = lodashStable.map(['a', 'b', 'c'], _.repeat);
19339 var value = { 'a': lodashStable.constant({ 'b': stubB }) };
19341 lodashStable.each(['a.b', ['a', 'b']], function(path) {
19351 lodashStable.each(['a.b', ['a', 'b']], function(path) {
19361 lodashStable.each(['get', 'result'], function(methodName) {
19369 lodashStable.each(['a', ['a']], function(path) {
19380 var actual = lodashStable.map(props, function(key) {
19406 lodashStable.each(['a.b', ['a', 'b']], function(path) {
19416 lodashStable.each(['a.b', ['a.b']], function(path) {
19438 lodashStable.each([['', ''], [[], ['']]], function(pair) {
19454 lodashStable.each(paths, function(path) {
19462 lodashStable.each(['constructor', ['constructor']], function(path) {
19472 expected = lodashStable.map(values, noop),
19475 lodashStable.each(paths, function(path) {
19476 var actual = lodashStable.map(values, function(value) {
19489 lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
19499 lodashStable.each(['a.b', ['a', 'b']], function(path) {
19509 lodashStable.each(paths, function(path) {
19521 expected = lodashStable.map(values, function(value) { return [value, value]; });
19523 lodashStable.each(['a.b', ['a', 'b']], function(path) {
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) {
19606 var largeArray = lodashStable.range(LARGE_ARRAY_SIZE).concat(null),
19623 lodashStable.times(2, function(index) {
19643 lodashStable.times(2, function(index) {
19688 lodashStable.times(2, function(index) {
19691 lodashStable.each(['map', 'filter'], function(methodName) {
19714 lodashStable.times(2, function(index) {
19734 lodashStable.each(['ceil', 'floor', 'round'], function(methodName) {
19804 var actual = lodashStable.map(values, function(args) {
19819 var expected = lodashStable.map(results, stubFalse),
19820 actual = lodashStable.map(results, lodashStable.isNaN);
19918 lodashStable.times(2, _.uniqueId);
19946 assert.ok(lodashStable.includes(array, actual));
19952 var expected = lodashStable.map(empties, noop);
19954 var actual = lodashStable.transform(empties, function(result, value) {
19969 assert.ok(lodashStable.includes(array, actual));
19986 assert.deepEqual(lodashStable.difference(actual, array), []);
20000 var expected = lodashStable.map(falsey, function(value) {
20004 var actual = lodashStable.map(falsey, function(size, index) {
20014 lodashStable.each([0, -1, -Infinity], function(n) {
20022 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
20038 var expected = lodashStable.map(empties, stubArray);
20040 var actual = lodashStable.transform(empties, function(result, value) {
20056 assert.deepEqual(lodashStable.difference(actual, lodashStable.values(object)), []);
20062 var actual = lodashStable.map([['a']], _.sampleSize);
20076 return lodashStable.isObject(value) ? undefined : {};
20094 lodashStable.each(['update', 'updateWith', 'set', 'setWith'], function(methodName) {
20100 updater = isUpdate ? lodashStable.constant(value) : value;
20105 lodashStable.each(['a', ['a']], function(path) {
20118 expected = lodashStable.map(props, lodashStable.constant(value));
20120 var actual = lodashStable.map(props, function(key) {
20123 return object[lodashStable.toString(key)];
20147 lodashStable.each(['a.b', ['a', 'b']], function(path) {
20159 lodashStable.each(['a.b', ['a.b']], function(path) {
20189 lodashStable.each([['', ''], [[], ['']]], function(pair, index) {
20210 lodashStable.each(paths, function(path) {
20222 lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) {
20239 var actual = lodashStable.map(values, function(value) {
20253 lodashStable.each(['a.b', ['a', 'b']], function(path) {
20273 lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) {
20276 updater = isUpdate ? lodashStable.constant(value) : value;
20281 'get': lodashStable.constant(value),
20315 var actual = lodashStable.times(1000, function(assert) {
20319 … assert.deepEqual(lodashStable.sortBy(lodashStable.uniqBy(actual, String), '0'), [[1, 2], [2, 1]]);
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) {
20399 lodashStable.each([new Set, realm.set], function(set) {
20455 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) {
20463 var expected = lodashStable.map(falsey, lodashStable.constant(array));
20465 var actual = lodashStable.map(falsey, function(start) {
20481 lodashStable.each([-3, -4, -Infinity], function(start) {
20489 lodashStable.each([2, 3], function(start) {
20503 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) {
20511 var expected = lodashStable.map(falsey, function(value) {
20515 var actual = lodashStable.map(falsey, function(end, index) {
20531 lodashStable.each([-3, -4, -Infinity], function(end) {
20541 var actual = lodashStable.map(positions, function(pos) {
20552 actual = lodashStable.map(array, _.slice);
20562 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
20566 lodashStable.each(['map', 'filter'], function(methodName) {
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);
20786 lodashStable.each(['orderBy', 'sortBy'], function(methodName) {
20815 var stableObject = lodashStable.zipObject('abcdefghijklmnopqrst'.split(''), stableArray);
20834 lodashStable.each([stableArray, stableObject], function(value, index) {
20860 var funcs = [func, lodashStable.partialRight(func, 'bogus')];
20862 lodashStable.each(['a', 0, [0]], function(props, index) {
20863 var expected = lodashStable.map(funcs, lodashStable.constant(
20869 var actual = lodashStable.map(funcs, function(func) {
20870 return lodashStable.reduce([props], func, objects);
20882 lodashStable.each(['sortedIndex', 'sortedLastIndex'], function(methodName) {
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) {
20935 lodashStable.each([
20976 lodashStable.each(['sortedIndexBy', 'sortedLastIndexBy'], function(methodName) {
21004 lodashStable.each([Math.ceil(MAX_ARRAY_LENGTH / 2), MAX_ARRAY_LENGTH], function(length) {
21010 lodashStable.each(values, function(value) {
21018 … var expected = (isSortedIndexBy ? !lodashStable.isNaN(value) : lodashStable.isFinite(value))
21033 lodashStable.each(['sortedIndexOf', 'sortedLastIndexOf'], function(methodName) {
21055 lodashStable.each([[1, 2, 3], [1, 1, 2, 2, 3], [1, 2, 3, 3, 3, 3, 3]], 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) {
21221 lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) {
21229 var expected = lodashStable.map(falsey, stubTrue);
21231 var actual = lodashStable.map(falsey, function(position) {
21241 lodashStable.each([-1, -3, -Infinity], function(position) {
21258 lodashStable.each(['startsWith', 'endsWith'], function(methodName) {
21269 assert.strictEqual(func({ 'toString': lodashStable.constant(string) }, chr), true);
21276 assert.strictEqual(func(string, { 'toString': lodashStable.constant(chr) }), true);
21285 …assert.strictEqual(func(string, 'b', { 'toString': lodashStable.constant(String(position)) }), tru…
21293 assert.ok(lodashStable.every(positions, function(position) {
21303 …lodashStable.each(['noop', 'stubTrue', 'stubFalse', 'stubArray', 'stubObject', 'stubString'], func…
21316 expected = lodashStable.map(values, lodashStable.constant(pair[0]));
21321 var actual = lodashStable.map(values, function(value, index) {
21357 lodashStable.each(['add', 'divide', 'multiply', 'subtract'], function(methodName) {
21381 lodashStable.times(2, function(index) {
21382 var actual = lodashStable.map(values, function(value) {
21478 lodashStable.each(['sum', 'sumBy'], function(methodName) {
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);
21565 var array = lodashStable.range(LARGE_ARRAY_SIZE),
21598 var array = lodashStable.range(LARGE_ARRAY_SIZE),
21634 var expected = lodashStable.map(falsey, function(value) {
21638 var actual = lodashStable.map(falsey, function(n) {
21648 lodashStable.each([0, -1, -Infinity], function(n) {
21656 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
21665 actual = lodashStable.map(array, _.take);
21674 var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1),
21716 var expected = lodashStable.map(falsey, function(value) {
21720 var actual = lodashStable.map(falsey, function(n) {
21730 lodashStable.each([0, -1, -Infinity], function(n) {
21738 lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) {
21747 actual = lodashStable.map(array, _.takeRight);
21756 var array = lodashStable.range(LARGE_ARRAY_SIZE),
21839 var array = lodashStable.range(LARGE_ARRAY_SIZE),
21858 array = lodashStable.range(LARGE_ARRAY_SIZE + 1);
21863 lodashStable.map(array.slice(1), square)
21958 var array = lodashStable.range(LARGE_ARRAY_SIZE),
21976 var array = lodashStable.range(LARGE_ARRAY_SIZE);
21996 array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
21997 expected = [1, 0, lodashStable.map(array.slice(1), square)];
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) {
22189 lodashStable.forOwn({
22257 lodashStable.times(2, function(index) {
22258 var settingsClone = lodashStable.clone(_.templateSettings);
22260 var settings = lodashStable.assign(index ? _.templateSettings : {}, {
22271 lodashStable.assign(_.templateSettings, settingsClone);
22278 lodashStable.times(2, function(index) {
22279 var settingsClone = lodashStable.clone(_.templateSettings);
22281 var settings = lodashStable.assign(index ? _.templateSettings : {}, {
22292 lodashStable.assign(_.templateSettings, settingsClone);
22309 settingsClone = lodashStable.clone(lodash.templateSettings);
22311 lodash.templateSettings = lodashStable.assign(lodash.templateSettings, {
22319 lodashStable.assign(lodash.templateSettings, settingsClone);
22331 _.templateSettings.imports._ = { 'escape': lodashStable.escape };
22350 lodashStable.forOwn({
22484 expected = lodashStable.map(values, stubString),
22487 var actual = lodashStable.map(values, function(value, index) {
22517 var object = { 'toString': lodashStable.constant('<%= a %>') },
22558 expected = lodashStable.map(values, stubTrue);
22560 var actual = lodashStable.map(values, function(value) {
22561 return lodashStable.includes(value, '__p');
22575 assert.ok(lodashStable.includes(source, '__p'));
22590 var expected = lodashStable.map(values, stubFalse);
22592 var actual = lodashStable.map(values, function(value) {
22593 return lodashStable.includes(value, 'sourceURL');
22603 compiles = lodashStable.map(array, _.template),
22606 var actual = lodashStable.map(compiles, function(compiled) {
22670 lodashStable.each([0, -2], function(length) {
22678 lodashStable.each(['', NaN, 4.6, '4'], function(length, index) {
22680 …assert.strictEqual(_.truncate(string, { 'length': { 'valueOf': lodashStable.constant(length) } }),…
22688 …assert.strictEqual(_.truncate({ 'toString': lodashStable.constant(string) }, { 'length': 5 }), 'hi…
22694 var actual = lodashStable.map([string, string, string], _.truncate),
22798 lodashStable.times(2, function(index) {
22975 lodashStable.each(['debounce', 'throttle'], function(methodName) {
23010 expected = lodashStable.times(isDebounce ? 1 : 2, lodashStable.constant(object));
23028 args = lodashStable.map(['a', 'b', 'c'], function(chr) { return [{}, chr]; }),
23179 lodashStable.each([-Infinity, NaN, Infinity], function(n) {
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) {
23309 var array = lodashStable.range(LARGE_ARRAY_SIZE + 1);
23311 var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
23316 assert.deepEqual(actual, lodashStable.map(array.slice(1), String));
23359 lodashStable.each(['slice', 'toArray'], function(methodName) {
23412 lodashStable.each(['toInteger', 'toSafeInteger'], function(methodName) {
23469 lodashStable.each(['toFinite', 'toInteger', 'toNumber', 'toSafeInteger'], function(methodName) {
23478 lodashStable.times(2, function(index) {
23479 var others = lodashStable.map(values, index ? Object : identity);
23481 var actual = lodashStable.map(others, function(value) {
23491 …lodashStable.each(['toFinite', 'toInteger', 'toLength', 'toNumber', 'toSafeInteger'], function(met…
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) {
23588 return lodashStable.flatMap(transforms, function(mod) {
23603 var expected = lodashStable.map(numbers, function(n) {
23604 return lodashStable.times(8, lodashStable.constant(n));
23607 var actual = lodashStable.map(values, function(value) {
23609 return lodashStable.flatMap(transforms, function(mod) {
23623 var expected = lodashStable.map(values, function(n) {
23624 return lodashStable.times(8, lodashStable.constant(isToNumber ? NaN : 0));
23627 var actual = lodashStable.map(values, function(value) {
23628 return lodashStable.flatMap(transforms, function(mod) {
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) {
23680 { 'valueOf': '1.1', 'toString': lodashStable.constant('2.2') },
23681 { 'valueOf': lodashStable.constant('1.1'), 'toString': '2.2' },
23682 { 'valueOf': lodashStable.constant('1.1'), 'toString': lodashStable.constant('2.2') },
23683 { 'valueOf': lodashStable.constant('-0x1a2b3c') },
23684 { 'toString': lodashStable.constant('-0x1a2b3c') },
23685 { 'valueOf': lodashStable.constant('0o12345') },
23686 { 'toString': lodashStable.constant('0o12345') },
23687 { 'valueOf': lodashStable.constant('0b101010') },
23688 { 'toString': lodashStable.constant('0b101010') }
23717 var actual = lodashStable.map(values, func);
23751 lodashStable.each(['toPairs', 'toPairsIn'], function(methodName) {
23759 actual = lodashStable.sortBy(func(object), 0);
23773 actual = lodashStable.sortBy(func(new Foo), 0);
23782 actual = lodashStable.sortBy(func(object), 0);
23818 lodashStable.each(['xo', Object('xo')], function(string) {
23819 var actual = lodashStable.sortBy(func(string), 0);
23842 lodashStable.each([array, lodashStable.map(array, Object)], function(value) {
23860 lodashStable.each([symbol, object, [symbol], [object]], function(value) {
23862 assert.ok(lodashStable.isSymbol(actual[0]));
23919 var actual = lodashStable.assign({ 'a': 1 }, _.toPlainObject(new Foo));
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) {
24080 return lodashStable.isArray(_.transform(array, noop));
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) {
24111 lodashStable.each([[], {}], function(accumulator) {
24112 var actual = lodashStable.map(values, function(value) {
24116 assert.ok(lodashStable.every(actual, function(result) {
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) {
24182 lodashStable.each({
24198 assert.ok(first !== object && lodashStable.isArray(first));
24201 assert.ok(first !== object && lodashStable.isPlainObject(first));
24210 var objects = lodashStable.filter(realm, function(value) {
24211 return lodashStable.isObject(value) && !lodashStable.isElement(value);
24214 var expected = lodashStable.map(objects, stubTrue);
24216 var actual = lodashStable.map(objects, function(object) {
24223 if (lodashStable.isTypedArray(object)) {
24237 lodashStable.each(['trim', 'trimStart', 'trimEnd'], function(methodName, index) {
24261 var object = { 'toString': lodashStable.constant(whitespace + 'a b c' + whitespace) },
24279 var object = { 'toString': lodashStable.constant('_-') },
24289 lodashStable.each([null, '_-'], function(chars) {
24311 actual = lodashStable.map([string, string, string], func);
24405 lodashStable.times(2, function(index) {
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));
24584 lodashStable.each(['`', '/'], function(entity) {
24597 lodashStable.each(['union', 'unionBy', 'unionWith'], function(methodName) {
24676 actual = _.unionWith(objects, others, lodashStable.isEqual);
24699 …lodashStable.each(['uniq', 'uniqBy', 'uniqWith', 'sortedUniq', 'sortedUniqBy'], function(methodNam…
24731 var actual = lodashStable.map(func([-0, 0]), lodashStable.toString);
24748 lodashStable.each(expected, function(value) {
24749 lodashStable.times(count, function() {
24760 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
24764 var actual = lodashStable.map(func(largeArray), lodashStable.toString);
24775 lodashStable.each(expected, function(value) {
24776 lodashStable.times(count, function() {
24788 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, Symbol);
24810 expected = lodashStable.map(expected, function(symbol) {
24814 lodashStable.each(expected, function(value) {
24815 lodashStable.times(count, function() {
24834 lodashStable.each(expected, function(value) {
24835 lodashStable.times(count, function() {
24853 actual = lodashStable.map(array, lodashStable.uniq);
24863 lodashStable.each(['uniqBy', 'sortedUniqBy'], function(methodName) {
24886 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function() {
24917 arrays = lodashStable.sortBy(arrays, 0);
24925 lodashStable.each({
24950 actual = _.uniqWith(objects, lodashStable.isEqual);
24958 var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) {
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);
24981 var actual = lodashStable.times(1000, function(assert) {
24985 assert.strictEqual(lodashStable.uniq(actual).length, actual.length);
25010 lodashStable.each(['a', ['a']], function(path) {
25021 expected = lodashStable.map(props, lodashStable.constant([true, false]));
25023 var actual = lodashStable.map(props, function(key) {
25025 return [_.unset(object, key), lodashStable.toString(key) in object];
25049 lodashStable.each(['a.b', ['a', 'b']], function(path) {
25064 lodashStable.each(paths, function(path) {
25076 lodashStable.each(['z', 'a.z', 'a.b.z', 'a.b.c.z'], function(path) {
25089 var actual = lodashStable.map(values, function(value) {
25106 lodashStable.each(paths, function(path) {
25116 lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) {
25181 expected = lodashStable.map(values, lodashStable.constant(_.unzip(array)));
25183 var actual = lodashStable.map(values, function(value, index) {
25200 return lodashStable.isObject(value) ? undefined : {};
25218 lodashStable.each(['update', 'updateWith'], function(methodName) {
25228 lodashStable.each(['a[0].b.c', ['a', '0', 'b', 'c']], function(path) {
25272 lodashStable.each(['values', 'valuesIn'], function(methodName) {
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) {
25409 lodashStable.each(["'", '\u2019'], function(apos) {
25410 lodashStable.times(2, function(index) {
25411 var actual = lodashStable.map(postfixes, function(postfix) {
25416 var expected = lodashStable.map(postfixes, function(postfix) {
25418 return lodashStable.map(words, function(word) {
25433 lodashStable.times(2, function(index) {
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);
25486 startTime = lodashStable.now();
25490 var endTime = lodashStable.now(),
25505 var p = _.wrap(lodashStable.escape, function(func, text) {
25529 expected = lodashStable.map(values, stubA);
25531 var actual = lodashStable.map(values, function(value, index) {
25542 var p = _.wrap(lodashStable.escape, function(func) {
25555 lodashStable.each(['xor', 'xorBy', 'xorWith'], function(methodName) {
25633 var array = lodashStable.range(LARGE_ARRAY_SIZE + 1),
25636 var actual = lodashStable.map(['head', 'last'], function(methodName) {
25686 actual = _.xorWith(objects, others, lodashStable.isEqual);
25696 lodashStable.each(['zipObject', 'zipObjectDeep'], function(methodName) {
25723 lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path, index) {
25733 var values = lodashStable.range(LARGE_ARRAY_SIZE),
25734 props = lodashStable.map(values, function(value) { return 'key' + value; }),
25788 expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2)));
25790 var actual = lodashStable.map(values, function(value, index) {
25802 lodashStable.each(['unzip', 'zip'], function(methodName, index) {
25804 func = lodashStable.bind(index ? func.apply : func.call, func, null);
25825 lodashStable.forOwn(object, function(pair, key) {
25855 var expected = lodashStable.map(falsey, stubArray);
25857 var actual = lodashStable.map(falsey, function(value) {
25921 lodashStable.each([false, true], function(implicit) {
25951 assert.deepEqual(lodashStable.toArray(wrapped), array);
25965 lodashStable.each(values, function(value) {
25982 assert.deepEqual(lodashStable.toArray(wrapped), array);
25983 …assert.deepEqual(lodashStable.toArray(wrapped), [], 'produces an empty array for exhausted iterato…
25986 assert.deepEqual(lodashStable.toArray(other), array, 'reset for new chain segments');
25987 assert.deepEqual(lodashStable.toArray(wrapped), [], 'iterator is still exhausted');
25998 var array = lodashStable.range(LARGE_ARRAY_SIZE),
26003 assert.deepEqual(lodashStable.toArray(wrapped), array);
26006 …assert.deepEqual(lodashStable.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain…
26061 assert.deepEqual(lodashStable.toArray(wrapped1), [4, 16]);
26062 assert.deepEqual(lodashStable.toArray(wrapped1), []);
26065 assert.deepEqual(lodashStable.toArray(wrapped2), [36, 64]);
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) {
26149 return lodashStable.eq(result, value);
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) {
26237 return lodashStable.eq(result, value);
26278 var expected = lodashStable.map(falsey, stubTrue);
26280 var actual = lodashStable.map(falsey, function(value, index) {
26283 return lodashStable.isEqual(result, []);
26320 var expected = lodashStable.map(falsey, stubTrue);
26322 var actual = lodashStable.map(falsey, function(value, index) {
26325 return lodashStable.eq(result, value);
26409 lodashStable.each(funcs, function(methodName) {
26463 lodashStable.each(funcs, function(methodName) {
26583 lodashStable.each(funcs, function(methodName) {
26714 lodashStable.each(stringMethods, function(methodName) {
26721 expected = lodashStable.map(values, stubString);
26723 var actual = lodashStable.map(values, function(value, index) {
26737 var allMethods = lodashStable.reject(_.functions(_).sort(), function(methodName) {
26738 return lodashStable.startsWith(methodName, '_');
26822 var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey);
26827 var arrays = lodashStable.map(falsey, stubArray);
26829 lodashStable.each(acceptFalsey, function(methodName) {
26833 var actual = lodashStable.map(falsey, function(value, index) {
26843 if (lodashStable.includes(returnArrays, methodName) && methodName != 'sample') {
26850 lodashStable.each(['chain', 'noConflict', 'runInContext'], function(methodName) {
26862 lodashStable.each(returnArrays, function(methodName) {
26876 assert.ok(lodashStable.isArray(actual), '_.' + methodName + ' returns an array');
26886 lodashStable.each(rejectFalsey, function(methodName) {
26887 var expected = lodashStable.map(falsey, stubTrue),
26890 var actual = lodashStable.map(falsey, function(value, index) {
26897 (!lodashStable.includes(checkFuncs, methodName) || (e.message == FUNC_ERROR_TEXT));
26909 lodashStable.each(noBinding, function(methodName) {
26931 assert.ok(lodashStable.every(_.functions(_), function(methodName) {
26932 return methodName.length > 2 || lodashStable.includes(shortNames, methodName);