Lines Matching refs:slice

63       slice = arrayProto.slice,
170 var empties = [[], {}].concat(falsey.slice(1));
305 console.log('test.js invoked with arguments: ' + JSON.stringify(slice.call(params)));
760 console.log('test.js invoked with arguments: ' + JSON.stringify(slice.call(params)));
1232 return slice.call(arguments);
1285 return args.slice(0, index);
1669 var actual = _.attempt(function() { return slice.call(arguments); }, 1, 2);
1800 var values = lodashStable.reject(falsey.slice(1), function(value) { return value == null; }),
2164 return slice.call(arguments);
2183 return slice.call(arguments);
3127 args = slice.call(arguments, 0, length - (length > 1 ? 1 : 0));
3181 var actual = _(falsey).thru(_.slice).compact().thru(_.slice).value();
3184 actual = _(falsey).thru(_.slice).push(true, 1).compact().push('a').value();
3196 var actual = _(largeArray).slice(1).compact().reverse().take().value();
3197 assert.deepEqual(actual, _.take(_.compact(_.slice(largeArray, 1)).reverse()));
3214 var actual = _(largeArray).slice(1).compact().value();
3215 pass = lodashStable.isEqual(actual, _.compact(_.slice(largeArray, 1)));
3335 function() { args1 || (args1 = slice.call(arguments)); return true; },
3336 function() { args2 || (args2 = slice.call(arguments)); }
3818 return slice.call(arguments);
3976 return slice.call(arguments);
4135 fn = function(a, b) { return slice.call(arguments); },
4775 args = slice.call(arguments);
4832 args = slice.call(arguments);
5015 args || (args = slice.call(arguments));
5140 assert.deepEqual(actual, array.slice(3));
5152 assert.deepEqual(values, array.slice(1));
5228 assert.deepEqual(actual, array.slice(0, -3));
5240 assert.deepEqual(values, array.slice(0, -1));
5278 args = slice.call(arguments);
5287 assert.deepEqual(_.dropRightWhile(objects, { 'b': 2 }), objects.slice(0, 2));
5293 assert.deepEqual(_.dropRightWhile(objects, ['b', 2]), objects.slice(0, 2));
5299 assert.deepEqual(_.dropRightWhile(objects, 'b'), objects.slice(0, 1));
5348 args = slice.call(arguments);
5357 assert.deepEqual(_.dropWhile(objects, { 'b': 2 }), objects.slice(1));
5363 assert.deepEqual(_.dropWhile(objects, ['b', 2]), objects.slice(1));
5369 assert.deepEqual(_.dropWhile(objects, 'b'), objects.slice(2));
5382 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
5402 assert.deepEqual(actual, array.slice(3));
6003 args || (args = slice.call(arguments));
6037 args || (args = slice.call(arguments));
6379 return slice.call(arguments);
6994 args || (args = slice.call(arguments));
7027 return args.slice(0, isOmitPick ? 2 : 1);
7041 argsList.push(slice.call(arguments));
7411 args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
7428 argsList.push(lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
7439 args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep));
8576 args || (args = slice.call(arguments));
8829 var array = [function() { return slice.call(arguments); }],
8975 assert.strictEqual(_.isArguments(slice), false);
9022 assert.strictEqual(_.isArray(slice), false);
9075 assert.strictEqual(_.isArrayBuffer(slice), false);
9129 assert.strictEqual(_.isArrayLike(slice), false);
9184 assert.strictEqual(_.isBoolean(slice), false);
9237 assert.strictEqual(_.isBuffer(slice), false);
9284 assert.strictEqual(_.isDate(slice), false);
9347 assert.strictEqual(_.isElement(slice), false);
9392 assert.strictEqual(_.isEmpty(slice), true);
9613 array2.reverse = array2.shift = array2.slice =
10373 args = slice.call(arguments, 0, length - (length > 2 ? 1 : 0));
10476 args = slice.call(arguments, 0, length - (length > 2 ? 1 : 0));
10529 assert.strictEqual(_.isError(slice), false);
10626 assert.strictEqual(_.isFunction(slice), true);
10827 assert.strictEqual(_.isMap(slice), false);
10888 argsList.push(slice.call(arguments, 0, -1));
11002 argsList.push(slice.call(arguments, 0, -1));
11045 assert.strictEqual(_.isNaN(slice), false);
11074 … var values = [Array, body && body.cloneNode, create, root.encodeURI, Promise, slice, Uint8Array],
11151 assert.strictEqual(baseIsNative(slice), true);
11153 slice[fakeSrcKey] = slice + '';
11154 assert.strictEqual(baseIsNative(slice), false);
11156 delete slice[fakeSrcKey];
11197 assert.strictEqual(_.isNil(slice), false);
11254 assert.strictEqual(_.isNull(slice), false);
11306 assert.strictEqual(_.isNumber(slice), false);
11339 assert.strictEqual(_.isObject(slice), true);
11418 var values = falsey.concat(true, _, slice, 1, 'a', symbol),
11613 assert.strictEqual(_.isRegExp(slice), false);
11665 assert.strictEqual(_.isSet(slice), false);
11730 assert.strictEqual(_.isString(slice), false);
11783 assert.strictEqual(_.isSymbol(slice), false);
11839 assert.strictEqual(_.isTypedArray(slice), false);
11901 assert.strictEqual(_.isUndefined(slice), false);
11960 assert.strictEqual(_.isWeakMap(slice), false);
12027 assert.strictEqual(_.isWeakSet(slice), false);
12063 Foo.prototype = root[methodName.slice(2)].prototype;
12106 var fn = function() { return slice.call(arguments); },
12338 assert.deepEqual(_.dropRightWhile(objects), objects.slice(0, 2));
12351 assert.deepEqual(_.dropWhile(objects.reverse()).reverse(), objects.reverse().slice(0, 2));
12364 assert.strictEqual(_.every(objects.slice(1)), true);
12589 assert.deepEqual(_.partition(objects), [objects.slice(0, 2), objects.slice(2)]);
12602 assert.deepEqual(_.pullAllBy(objects.slice(), [{ 'a': 1, 'b': 0 }]), [objects[0]]);
12685 assert.deepEqual(_.sortBy(objects.slice().reverse()), [objects[0], objects[2], objects[1]]);
12741 assert.deepEqual(_.takeRightWhile(objects), objects.slice(2));
12754 assert.deepEqual(_.takeWhile(objects.reverse()), objects.reverse().slice(2));
12798 assert.deepEqual(_.unionBy(objects.slice(0, 1), [objects[2]]), [objects[0], objects[2]]);
12811 assert.deepEqual(_.xorBy(objects, objects.slice(1)), [objects[0]]);
13573 expected = [1, 0, _.map(array.slice(1), square)];
13575 _(array).slice(1).map(function(value, index, array) {
13576 args || (args = slice.call(arguments));
13579 assert.deepEqual(args, [1, 0, array.slice(1)]);
13582 _(array).slice(1).map(square).map(function(value, index, array) {
13583 args || (args = slice.call(arguments));
13589 _(array).slice(1).map(square).map(function(value, index) {
13590 args || (args = slice.call(arguments));
13596 _(array).slice(1).map(square).map(function(value) {
13597 args || (args = slice.call(arguments));
13603 _(array).slice(1).map(square).map(function() {
13604 args || (args = slice.call(arguments));
14625 args || (args = slice.call(arguments));
14997 expected = array.slice();
15041 var array = arrays[index].slice();
15055 var array = arrays[index].slice();
15468 return slice.call(arguments);
15620 return slice.call(arguments);
15773 var actions = slice.call(value.__actions__),
16068 return slice.call(arguments);
16148 transform = function() { argsList.push(slice.call(arguments)); },
16796 return slice.call(arguments);
16900 args = slice.call(arguments);
17021 args = slice.call(arguments);
17364 var fn = function() { return slice.call(arguments); },
17384 fn = function() { return slice.call(arguments); },
17448 var fn = function() { return slice.call(arguments); },
17482 return slice.call(arguments);
17661 fn = function() { return slice.call(arguments); },
17718 assert.deepEqual(actual, [objects.slice(0, 2), objects.slice(2)]);
17800 assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice });
18257 args || (args = slice.call(arguments));
18465 var values = falsey.slice(),
18707 return slice.call(arguments);
18808 args || (args = slice.call(arguments));
18815 args || (args = slice.call(arguments));
18833 args || (args = slice.call(arguments));
18844 args || (args = slice.call(arguments));
18870 args || (args = slice.call(arguments));
18877 args || (args = slice.call(arguments));
18895 args || (args = slice.call(arguments));
18906 args || (args = slice.call(arguments));
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)];
19107 _(array).slice(1)[methodName](function(value, index, array) {
19108 args || (args = slice.call(arguments));
19111 assert.deepEqual(args, [1, 0, array.slice(1)]);
19114 _(array).slice(1).map(square)[methodName](function(value, index, array) {
19115 args || (args = slice.call(arguments));
19121 _(array).slice(1).map(square)[methodName](function(value, index) {
19122 args || (args = slice.call(arguments));
19128 _(array).slice(1).map(square)[methodName](function(value) {
19129 args || (args = slice.call(arguments));
19135 _(array).slice(1).map(square)[methodName](function() {
19136 args || (args = slice.call(arguments));
19167 clone = array.slice();
19170 var args = slice.call(arguments);
19171 args[2] = args[2].slice();
19545 return slice.call(arguments);
19594 return slice.call(arguments);
19624 var array = (index ? largeArray : smallArray).slice(),
19625 clone = array.slice(),
19631 assert.deepEqual(actual, clone.slice().reverse());
19644 var array = (index ? largeArray : smallArray).slice(),
19645 expected = array.slice(),
19646 actual = _(array).slice(1).reverse().value();
19648 assert.deepEqual(actual, expected.slice(1).reverse());
19668 expected = array.slice();
19671 var wrapped = _(array).slice(1).map(String).reverse(),
19689 var clone = (index ? largeArray : smallArray).slice();
19692 var array = clone.slice(),
19693 expected = clone.slice(1, -1).reverse(),
19698 array = clone.slice();
19701 assert.deepEqual(actual, [3].concat(expected.slice(0, -1)));
19715 var array = (index ? largeArray : smallArray).slice(),
19716 expected = array.slice().reverse(),
20440 var actual = _.slice(array);
20448 assert.deepEqual(_.slice(array, 1), [2, 3]);
20449 assert.deepEqual(_.slice(array, 1, 3), [2, 3]);
20456 assert.deepEqual(_.slice(array, start), []);
20466 return _.slice(array, start);
20475 assert.deepEqual(_.slice(array, -1), [3]);
20482 assert.deepEqual(_.slice(array, start), array);
20490 assert.deepEqual(_.slice(array, start, 2), []);
20497 assert.deepEqual(_.slice(array, 0, 1), [1]);
20504 assert.deepEqual(_.slice(array, 0, end), array);
20516 return index ? _.slice(array, 0, end) : _.slice(array, 0);
20525 assert.deepEqual(_.slice(array, 0, -1), [1, 2]);
20532 assert.deepEqual(_.slice(array, 0, end), []);
20542 return _.slice.apply(_, [array].concat(pos));
20552 actual = lodashStable.map(array, _.slice);
20567 assert.deepEqual(wrapped[methodName]().slice(0, -1).value(), array.slice(0, -1));
20568 assert.deepEqual(wrapped[methodName]().slice(1).value(), array.slice(1));
20569 assert.deepEqual(wrapped[methodName]().slice(1, 3).value(), array.slice(1, 3));
20570 assert.deepEqual(wrapped[methodName]().slice(-1).value(), array.slice(-1));
20572 assert.deepEqual(wrapped[methodName]().slice(length).value(), array.slice(length));
20573 assert.deepEqual(wrapped[methodName]().slice(3, 2).value(), array.slice(3, 2));
20574 … assert.deepEqual(wrapped[methodName]().slice(0, -length).value(), array.slice(0, -length));
20575 assert.deepEqual(wrapped[methodName]().slice(0, null).value(), array.slice(0, null));
20577 assert.deepEqual(wrapped[methodName]().slice(0, length).value(), array.slice(0, length));
20578 assert.deepEqual(wrapped[methodName]().slice(-length).value(), array.slice(-length));
20579 assert.deepEqual(wrapped[methodName]().slice(null).value(), array.slice(null));
20581 assert.deepEqual(wrapped[methodName]().slice(0, 1).value(), array.slice(0, 1));
20582 assert.deepEqual(wrapped[methodName]().slice(NaN, '1').value(), array.slice(NaN, '1'));
20584 assert.deepEqual(wrapped[methodName]().slice(0.1, 1.1).value(), array.slice(0.1, 1.1));
20585 assert.deepEqual(wrapped[methodName]().slice('0', 1).value(), array.slice('0', 1));
20586 assert.deepEqual(wrapped[methodName]().slice(0, '1').value(), array.slice(0, '1'));
20587 assert.deepEqual(wrapped[methodName]().slice('1').value(), array.slice('1'));
20588 assert.deepEqual(wrapped[methodName]().slice(NaN, 1).value(), array.slice(NaN, 1));
20589 assert.deepEqual(wrapped[methodName]().slice(1, NaN).value(), array.slice(1, NaN));
20986 args || (args = slice.call(arguments));
21116 return slice.call(arguments);
21459 args || (args = slice.call(arguments));
21575 assert.deepEqual(values, array.slice(1));
21601 actual = _(array).slice(0, 1).tail().map(iteratee).value();
21607 actual = _(array).filter().slice(0, 1).tail().map(iteratee).value();
21811 args = slice.call(arguments);
21820 assert.deepEqual(_.takeRightWhile(objects, { 'b': 2 }), objects.slice(2));
21826 assert.deepEqual(_.takeRightWhile(objects, ['b', 2]), objects.slice(2));
21832 assert.deepEqual(_.takeRightWhile(objects, 'b'), objects.slice(1));
21845 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21863 lodashStable.map(array.slice(1), square)
21866 _(array).slice(1).takeRightWhile(function(value, index, array) {
21867 args = slice.call(arguments);
21870 assert.deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array.slice(1)]);
21872 _(array).slice(1).map(square).takeRightWhile(function(value, index, array) {
21873 args = slice.call(arguments);
21878 _(array).slice(1).map(square).takeRightWhile(function(value, index) {
21879 args = slice.call(arguments);
21884 _(array).slice(1).map(square).takeRightWhile(function(index) {
21885 args = slice.call(arguments);
21890 _(array).slice(1).map(square).takeRightWhile(function() {
21891 args = slice.call(arguments);
21931 args = slice.call(arguments);
21940 assert.deepEqual(_.takeWhile(objects, { 'b': 2 }), objects.slice(0, 1));
21946 assert.deepEqual(_.takeWhile(objects, ['b', 2]), objects.slice(0, 1));
21951 assert.deepEqual(_.takeWhile(objects, 'b'), objects.slice(0, 2));
21964 assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse());
21997 expected = [1, 0, lodashStable.map(array.slice(1), square)];
21999 _(array).slice(1).takeWhile(function(value, index, array) {
22000 args = slice.call(arguments);
22003 assert.deepEqual(args, [1, 0, array.slice(1)]);
22005 _(array).slice(1).map(square).takeWhile(function(value, index, array) {
22006 args = slice.call(arguments);
22011 _(array).slice(1).map(square).takeWhile(function(value, index) {
22012 args = slice.call(arguments);
22017 _(array).slice(1).map(square).takeWhile(function(value) {
22018 args = slice.call(arguments);
22023 _(array).slice(1).map(square).takeWhile(function() {
22024 args = slice.call(arguments);
23029 expected = args.slice(),
23030 queue = args.slice();
23045 assert.deepEqual(actual, expected.slice(0, isDebounce ? 0 : 1));
23048 assert.deepEqual(actual, expected.slice(0, actual.length));
23197 args || (args = slice.call(arguments));
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));
24193 args || (args = slice.call(arguments));
24391 assert.deepEqual(_.split(string, '', 6), expected.slice(0, 6));
24522 return slice.call(arguments);
24652 args || (args = slice.call(arguments));
24874 var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3);
24901 args || (args = slice.call(arguments));
24910 var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3),
24919 expected = isSorted ? [[1], [2], [3]] : arrays.slice(0, 3);
25170 args || (args = slice.call(arguments));
25518 args || (args = slice.call(arguments));
25634 wrapped = _(array).slice(1)[methodName]([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]);
25669 args || (args = slice.call(arguments));
25776 args || (args = slice.call(arguments));