Lines Matching refs:index
2683 var index = (fromIndex || 0) - 1,
2686 while (++index < length) {
2687 if (array[index] === value) {
2688 return index;
2750 var index = -1,
2753 while (++index < length && chars.indexOf(string.charAt(index)) > -1) {}
2754 return index;
2767 var index = string.length;
2769 while (index-- && chars.indexOf(string.charAt(index)) > -1) {}
2770 return index;
2783 return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);
2796 var index = -1,
2801 while (++index < length) {
2802 var result = baseCompareAscending(objCriteria[index], othCriteria[index]);
2814 return object.index - other.index;
2863 index = fromRight ? (fromIndex || length) : ((fromIndex || 0) - 1);
2865 while ((fromRight ? index-- : ++index < length)) {
2866 var other = array[index];
2868 return index;
2908 var index = -1,
2913 while (++index < length) {
2914 if (array[index] === placeholder) {
2915 array[index] = PLACEHOLDER;
2916 result[++resIndex] = index;
2933 index = -1,
2938 while (++index < length) {
2939 var value = array[index],
2940 computed = iteratee ? iteratee(value, index, array) : value;
2942 if (!index || seen !== computed) {
2959 var index = -1,
2962 while (++index < length && isSpace(string.charCodeAt(index))) {}
2963 return index;
2975 var index = string.length;
2977 while (index-- && isSpace(string.charCodeAt(index))) {}
2978 return index;
3460 index = isRight ? end : start - 1,
3468 index += dir;
3471 value = array[index];
3476 computed = iteratee(value, index, array),
3630 var index = -1,
3634 while (++index < length) {
3635 array[index] = source[index];
3650 var index = -1,
3653 while (++index < length) {
3654 if (iteratee(array[index], index, array) === false) {
3692 var index = -1,
3695 while (++index < length) {
3696 if (!predicate(array[index], index, array)) {
3713 var index = -1,
3718 while (++index < length) {
3719 var value = array[index];
3720 if (predicate(value, index, array)) {
3737 var index = -1,
3741 while (++index < length) {
3742 result[index] = iteratee(array[index], index, array);
3755 var index = -1,
3759 while (++index < length) {
3760 var value = array[index];
3776 var index = -1,
3780 while (++index < length) {
3781 var value = array[index];
3802 var index = -1,
3806 accumulator = array[++index];
3808 while (++index < length) {
3809 accumulator = iteratee(accumulator, array[index], index, array);
3848 var index = -1,
3851 while (++index < length) {
3852 if (predicate(array[index], index, array)) {
3905 var index = -1,
3908 while (++index < length) {
3909 var key = props[index],
3931 var index = -1,
3937 while(++index < propsLength) {
3938 var key = props[index];
3941 result[index] = isIndex(key, length) ? collection[key] : undefined;
3943 result[index] = collection[key];
3963 var index = -1,
3966 while (++index < length) {
3967 var key = props[index];
3983 var index = -1,
3986 while (++index < length) {
3987 var key = methodNames[index];
4139 var index = -1,
4151 while (++index < length) {
4152 var value = array[index];
4184 var index = -1,
4187 while (++index < length) {
4188 if (iteratee(iterable[index], index, iterable) === false) {
4230 baseEach(collection, function(value, index, collection) {
4231 result = !!predicate(value, index, collection);
4248 baseEach(collection, function(value, index, collection) {
4249 if (predicate(value, index, collection)) {
4292 var index = (fromIndex || 0) - 1,
4297 while (++index < length) {
4298 var value = array[index];
4332 var index = -1,
4337 while (++index < length) {
4338 var key = props[index];
4419 var index = -1,
4424 while (++index < length) {
4425 var key = props[index];
4445 var index = -1,
4452 result[++index] = func ? func.apply(value, args) : undefined;
4581 var index = -1,
4584 while (++index < length) {
4585 if ((noCustomizer && strictCompareFlags[index])
4586 ? values[index] !== object[props[index]]
4587 : !hasOwnProperty.call(object, props[index])
4592 index = -1;
4593 while (++index < length) {
4594 var key = props[index];
4595 if (noCustomizer && strictCompareFlags[index]) {
4599 srcValue = values[index];
4787 var index = parseFloat(indexes[length]);
4788 if (index != previous && isIndex(index)) {
4789 var previous = index;
4790 splice.call(array, index, 1);
4824 eachFunc(collection, function(value, index, collection) {
4827 : iteratee(accumulator, value, index, collection)
4855 var index = -1,
4870 while (++index < length) {
4871 result[index] = array[index + start];
4889 baseEach(collection, function(value, index, collection) {
4890 result = predicate(value, index, collection);
4906 var index = -1,
4922 while (++index < length) {
4923 var value = array[index],
4924 computed = iteratee ? iteratee(value, index, array) : value;
4959 var index = -1,
4963 while (++index < length) {
4964 result[index] = object[props[index]];
4984 var index = -1,
4987 while (++index < length) {
4989 action = actions[index];
5093 case 3: return function(value, index, collection) {
5094 return func.call(thisArg, value, index, collection);
5096 case 4: return function(accumulator, value, index, collection) {
5097 return func.call(thisArg, accumulator, value, index, collection);
5217 var index = -1,
5220 while (++index < length) {
5221 var value = collection[index];
5222 setter(result, value, iteratee(value, index, collection), collection);
5258 var index = 0;
5259 while (++index < length) {
5260 var source = arguments[index];
5308 var index = -1,
5313 while (++index < length) {
5314 result = callback(result, array[index], index);
5404 index = length,
5407 while (index--) {
5408 args[index] = arguments[index];
5594 var index = -1,
5603 while (result && ++index < arrLength) {
5604 var arrValue = array[index],
5605 othValue = other[index];
5610 ? customizer(othValue, arrValue, index)
5611 : customizer(arrValue, othValue, index);
5696 index = -1;
5698 while (++index < objLength) {
5699 var key = objProps[index],
5752 baseEach(collection, function(value, index, collection) {
5753 var current = iteratee(value, index, collection);
5814 var index = -1,
5817 while (++index < length) {
5818 var data = transforms[index],
5844 result.index = array.index;
5953 function isIterateeCall(value, index, object) {
5957 var type = typeof index;
5960 prereq = isLength(length) && isIndex(index, length);
5962 prereq = type == 'string' && index in object;
5964 return prereq && object[index] === value;
6085 var index = -1,
6089 while (++index < length) {
6090 var key = props[index];
6133 var index = indexes[length];
6134 array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
6221 var index = -1,
6224 while (++index < propsLength) {
6225 var key = props[index];
6289 var index = 0,
6294 while (index < length) {
6295 result[++resIndex] = baseSlice(array, index, (index += size));
6315 var index = -1,
6320 while (++index < length) {
6321 var value = array[index];
6350 var index = -1,
6353 while (++index < length) {
6354 var value = arguments[index];
6359 return baseDifference(value, baseFlatten(arguments, false, true, ++index));
6530 var index = -1;
6532 while (++index < length && predicate(array[index], index, array)) {}
6533 return baseSlice(array, index);
6576 var index = -1,
6580 while (++index < length) {
6581 if (predicate(array[index], index, array)) {
6582 return index;
6745 var index = binaryIndex(array, value),
6746 other = array[index];
6748 return (value === value ? value === other : other !== other) ? index : -1;
6806 index = -1,
6812 while (++index < length) {
6813 value = array[index];
6879 var index = length;
6881 …index = (fromIndex < 0 ? nativeMax(length + fromIndex, 0) : nativeMin(fromIndex || 0, length - 1))…
6883 index = binaryIndex(array, value, true) - 1;
6884 var other = array[index];
6885 return (value === value ? value === other : other !== other) ? index : -1;
6888 return indexOfNaN(array, index, true);
6890 while (index--) {
6891 if (array[index] === value) {
6892 return index;
6926 var index = 0,
6930 while (++index < length) {
6932 value = arguments[index];
7005 var index = -1,
7010 while (++index < length) {
7011 var value = array[index];
7012 if (predicate(value, index, array)) {
7014 splice.call(array, index--, 1);
7313 var index = -1;
7315 while (++index < length && predicate(array[index], index, array)) {}
7316 return baseSlice(array, 0, index);
7429 var index = -1,
7433 while (++index < length) {
7434 result[index] = arrayMap(array, baseProperty(index));
7482 var index = -1,
7485 while (++index < length) {
7486 var array = arguments[index];
7539 var index = -1,
7546 while (++index < length) {
7547 var key = props[index];
7549 result[key] = values[index];
7989 var index = findIndex(collection, predicate, thisArg);
7990 return index > -1 ? collection[index] : undefined;
8522 return func(collection, function(value, index, collection) {
8523 return !predicate(value, index, collection);
8574 var index = -1,
8578 while (++index < length) {
8579 var rand = baseRandom(0, index);
8580 if (index != rand) {
8581 result[index] = result[rand];
8583 result[rand] = collection[index];
8705 var index = -1,
8714 …result[++index] = { 'criteria': iteratee(value, key, collection), 'index': index, 'value': value };
8747 var index = -1,
8759 result[++index] = { 'criteria': criteria, 'index': index, 'value': value };
9397 var index = 0,
9398 result = funcs[index].apply(this, arguments);
9400 while (++index < length) {
9401 result = funcs[index].call(this, result);
9442 var index = fromIndex,
9443 result = funcs[index].apply(this, arguments);
9445 while (index--) {
9446 result = funcs[index].call(this, result);
10891 var index = -1,
10896 while (++index < length) {
10897 var key = props[index],
10987 index = -1,
10992 while (++index < length) {
10993 result[index] = (index + '');
11155 var index = -1,
11160 while (++index < length) {
11161 var key = props[index];
11162 result[index] = [key, object[key]];
11287 (isArr ? arrayEach : baseForOwn)(object, function(value, index, object) {
11288 return iteratee(accumulator, value, index, object);
11435 var camelCase = createCompounder(function(result, word, index) {
11437 return result + (index ? (word.charAt(0).toUpperCase() + word.slice(1)) : word);
11590 var kebabCase = createCompounder(function(result, word, index) {
11591 return result + (index ? '-' : '') + word.toLowerCase();
11794 var snakeCase = createCompounder(function(result, word, index) {
11795 return result + (index ? '_' : '') + word.toLowerCase();
11819 var startCase = createCompounder(function(result, word, index) {
11820 return result + (index ? ' ' : '') + (word.charAt(0).toUpperCase() + word.slice(1));
11963 index = 0,
11986 source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
12000 index = offset + match.length;
12217 newEnd = match.index;
12222 var index = result.lastIndexOf(separator);
12223 if (index > -1) {
12224 result = result.slice(0, index);
12473 index = -1,
12482 while (++index < length) {
12483 var methodName = methodNames[index],
12639 var index = -1,
12643 while (++index < length) {
12644 result[index] = start;
12681 var index = -1,
12685 while (++index < n) {
12686 if (index < MAX_ARRAY_LENGTH) {
12687 result[index] = iteratee(index);
12689 iteratee(index);
12980 arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
12981 var isFilter = index == LAZY_FILTER_FLAG;
12988 result.filtered = filtered || isFilter || (index == LAZY_WHILE_FLAG && result.dir < 0);
12989 iteratees.push({ 'iteratee': getCallback(iteratee, thisArg, 3), 'type': index });
12995 arrayEach(['drop', 'take'], function(methodName, index) {
13005 result[countName] = index ? nativeMin(value, n) : (value + n);
13023 arrayEach(['first', 'last'], function(methodName, index) {
13024 var takeName = 'take' + (index ? 'Right': '');
13032 arrayEach(['initial', 'rest'], function(methodName, index) {
13033 var dropName = 'drop' + (index ? '' : 'Right');
13041 arrayEach(['pluck', 'where'], function(methodName, index) {
13042 var operationName = index ? 'filter' : 'map',
13043 createCallback = index ? baseMatches : baseProperty;
13046 return this[operationName](createCallback(index ? value : (value + '')));
13056 return this.filter(function(value, index, array) {
13057 done = done && (isRight ? index < lastIndex : index > lastIndex);
13058 lastIndex = index;
13059 return done || (done = !iteratee(value, index, array));
13065 return this.filter(function(value, index, array) {
13066 return !iteratee(value, index, array);
13312 FontWrapper.prototype.getFont = function(index){
13313 if(!this.pdfFonts[index]){
13315 var pseudoName = this.name + index;
13321 this.pdfFonts[index] = this.pdfkitDoc.font(this.path, pseudoName)._font;
13323 this.postscriptName = this.pdfFonts[index].name;
13327 return this.pdfFonts[index];
13363 var index = _.findIndex(self.charCatalogue, characterFitInFontWithIndex);
13365 if(index < 0){
13366 index = self.charCatalogue.length;
13367 self.charCatalogue[index] = [];
13370 var font = self.getFont(index);
13374 if(!_.includes(self.charCatalogue[index], charCode)){
13375 self.charCatalogue[index].push(charCode);
13476 return _.any(linearNodeList, function (node, index, followingNodeList) {
13481 var followingNodesOnPage = _.chain(followingNodeList).drop(index + 1).filter(function (node0) {
13485 var nodesOnNextPage = _.chain(followingNodeList).drop(index + 1).filter(function (node0) {
13489 var previousNodesOnPage = _.chain(followingNodeList).take(index).filter(function (node0) {
14011 var index = callbacks.indexOf(cb);
14012 if (index >= 0) {
14013 callbacks.splice(index, 1);
16248 PageElementWriter.prototype.addLine = function(line, dontUpdateContextPosition, index) {
16250 return self.writer.addLine(line, dontUpdateContextPosition, index);
16254 PageElementWriter.prototype.addImage = function(image, index) {
16256 return self.writer.addImage(image, index);
16260 PageElementWriter.prototype.addQr = function(qr, index) {
16262 return self.writer.addQr(qr, index);
16266 PageElementWriter.prototype.addVector = function(vector, ignoreContextX, ignoreContextY, index) {
16267 return this.writer.addVector(vector, ignoreContextX, ignoreContextY, index);
16394 function addPageItem(page, item, index) {
16395 if(index === null || index === undefined || index < 0 || index > page.items.length) {
16398 page.items.splice(index, 0, item);
16402 ElementWriter.prototype.addLine = function(line, dontUpdateContextPosition, index) {
16420 }, index);
16462 ElementWriter.prototype.addImage = function(image, index) {
16479 }, index);
16486 ElementWriter.prototype.addQr = function(qr, index) {
16504 this.addVector(vector, true, true, index);
16530 ElementWriter.prototype.addVector = function(vector, ignoreContextX, ignoreContextY, index) {
16540 }, index);
16925 … this.drawVerticalLine(xs[i].x, y1 - hzLineOffset, y2 + this.bottomLineWidth, xs[i].index, writer);
16927 var colIndex = xs[i].index;
17006 result.push({ x: self.rowSpanData[i].left, index: i});
17016 …result.push({ x: self.rowSpanData[self.rowSpanData.length - 1].left, index: self.rowSpanData.lengt…
29532 Data.prototype.byteAt = function(index) {
29533 return this.data[index];
30135 var added, alphabet, carry, i, index, isUpperCase, last, length, next, result;
30143 index = alphabet.indexOf(last.toLowerCase());
30144 if (index === -1) {
30148 next = alphabet.charAt((index + 1) % length);
30153 carry = index + 1 >= length;
30329 …var code, count, endCode, glyphId, glyphIds, i, idDelta, idRangeOffset, index, saveOffset, segCoun…
30399 index = idRangeOffset[i] / 2 + (code - start) - (segCount - i);
30400 glyphId = glyphIds[index] || 0;
30872 var index;
30877 index = this.glyphNameIndex[code];
30878 if (index <= 257) {
30879 return POSTSCRIPT_GLYPHS[index];
30881 return this.names[index - 258] || '.notdef';
30894 …var id, index, indexes, position, post, raw, string, strings, table, _i, _j, _k, _len, _len1, _len…
30920 index = indexes[_j];
30921 table.writeUInt16(index);
31161 var data, index, length, loca, numberOfContours, raw, xMax, xMin, yMax, yMin;
31167 index = loca.indexOf(id);
31172 data.pos = this.offset + index;
32392 var index;
32397 index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
32398 return this.data[index];
32401 …index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (cod…
32402 return this.data[index];
32405 index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];
32406 index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];
32407 index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
32408 return this.data[index];
65620 var chunkSize, colors, i, index, key, section, short, text, _i, _j, _ref;
65676 index = text.indexOf(0);
65677 key = String.fromCharCode.apply(String, text.slice(0, index));
65678 this.text[key] = String.fromCharCode.apply(String, text.slice(index + 1));
66123 var index = img.indexOf('base64,');
66124 if (index < 0) {
66128 return new Buffer(img.substring(index + 7), 'base64');