Lines Matching +full:g +full:- +full:guard
11 /** Used as a safe reference for `undefined` in pre-ES5 environments. */
21 var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
24 /** Used to stand-in for `undefined` hash values. */
75 MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
128 var reEmptyStringLeading = /\b__p \+= '';/g,
129 reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
130 reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
133 var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
134 reUnescapedHtml = /[&<>"']/g,
139 var reEscape = /<%-([\s\S]+?)%>/g,
140 reEvaluate = /<%([\s\S]+?)%>/g,
141 reInterpolate = /<%=([\s\S]+?)%>/g;
146 …rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:…
150 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
152 var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
156 var reTrim = /^\s+|\s+$/g,
166 var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
169 var reEscapeChar = /\\(\\)?/g;
173 …* [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexica…
175 var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
181 var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
190 var reIsOctal = /^0o[0-7]+$/i;
193 var reIsUint = /^(?:0|[1-9]\d*)$/;
196 var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
202 var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
205 var rsAstralRange = '\\ud800-\\udfff',
206 rsComboMarksRange = '\\u0300-\\u036f',
207 reComboHalfMarksRange = '\\ufe20-\\ufe2f',
208 rsComboSymbolsRange = '\\u20d0-\\u20ff',
210 rsDingbatRange = '\\u2700-\\u27bf',
211 rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
213 rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
214 rsPunctuationRange = '\\u2000-\\u206f',
216 rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
229 rsFitz = '\\ud83c[\\udffb-\\udfff]',
232 rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
233 rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
245 rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
246 rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
252 var reApos = RegExp(rsApos, 'g');
258 var reComboMark = RegExp(rsCombo, 'g');
260 /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
261 var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
273 ].join('|'), 'g');
275 … detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog…
279 var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
291 var templateCounter = -1;
327 // Latin-1 Supplement block.
345 // Latin Extended-A block.
353 '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
354 '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
411 /** Built-in method references without a dependency on `root`. */
459 /*--------------------------------------------------------------------------*/
492 var index = -1,
512 var index = -1,
535 while (length--) {
554 var index = -1,
575 var index = -1,
600 return !!length && baseIndexOf(array, value, 0) > -1;
613 var index = -1,
634 var index = -1,
653 var index = -1,
676 var index = -1,
703 accumulator = array[--length];
705 while (length--) {
722 var index = -1,
795 * @returns {number} Returns the index of the matched value, else `-1`.
799 index = fromIndex + (fromRight ? 1 : -1);
801 while ((fromRight ? index-- : ++index < length)) {
806 return -1;
816 * @returns {number} Returns the index of the matched value, else `-1`.
832 * @returns {number} Returns the index of the matched value, else `-1`.
835 var index = fromIndex - 1,
843 return -1;
933 while (length--) {
950 index = -1,
972 var index = -1,
983 * of key-value pairs for `object` corresponding to the property names of `props`.
988 * @returns {Object} Returns the key-value pairs.
1047 var index = -1,
1050 while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1066 while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1082 while (length--) {
1091 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
1172 * Converts `map` to its key-value pairs.
1176 * @returns {Array} Returns the key-value pairs.
1179 var index = -1,
1212 var index = -1,
1235 var index = -1,
1245 * Converts `set` to its value-value pairs.
1249 * @returns {Array} Returns the value-value pairs.
1252 var index = -1,
1269 * @returns {number} Returns the index of the matched value, else `-1`.
1272 var index = fromIndex - 1,
1280 return -1;
1291 * @returns {number} Returns the index of the matched value, else `-1`.
1295 while (index--) {
1375 /*--------------------------------------------------------------------------*/
1403 * // Create a suped-up `defer` in Node.js.
1409 /** Built-in constructor references. */
1420 /** Used for built-in method references. */
1425 /** Used to detect overreaching core-js shims. */
1426 var coreJsData = context['__core-js_shared__'];
1445 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1459 .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
1462 /** Built-in value references. */
1483 /** Mocked built-ins. */
1488 /* Built-in method references for those with the same name as other `lodash` methods. */
1503 /* Built-in method references that are verified to be native. */
1529 /*------------------------------------------------------------------------*/
1720 * Used to detect `data` property values to be HTML-escaped.
1776 /*------------------------------------------------------------------------*/
1825 result.__dir__ = -1;
1829 result.__dir__ *= -1;
1851 length = end - start,
1852 index = isRight ? end : (start - 1),
1864 while (length-- && resIndex < takeCount) {
1867 var iterIndex = -1,
1895 /*------------------------------------------------------------------------*/
1902 * @param {Array} [entries] The key-value pairs to cache.
1905 var index = -1,
1916 * Removes all key-value entries from the hash.
1939 this.size -= result ? 1 : 0;
1999 /*------------------------------------------------------------------------*/
2006 * @param {Array} [entries] The key-value pairs to cache.
2009 var index = -1,
2020 * Removes all key-value entries from the list cache.
2047 var lastIndex = data.length - 1;
2053 --this.size;
2083 return assocIndexOf(this.__data__, key) > -1;
2116 /*------------------------------------------------------------------------*/
2119 * Creates a map cache object to store key-value pairs.
2123 * @param {Array} [entries] The key-value pairs to cache.
2126 var index = -1,
2137 * Removes all key-value entries from the map.
2163 this.size -= result ? 1 : 0;
2219 /*------------------------------------------------------------------------*/
2230 var index = -1,
2271 /*------------------------------------------------------------------------*/
2274 * Creates a stack cache object to store key-value pairs.
2278 * @param {Array} [entries] The key-value pairs to cache.
2286 * Removes all key-value entries from the stack.
2354 if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
2373 /*------------------------------------------------------------------------*/
2376 * Creates an array of the enumerable property names of the array-like `value`.
2397 // Node.js 0.10 has enumerable non-index properties on buffers.
2399 // PhantomJS 2 has enumerable non-index properties on typed arrays.
2419 return length ? array[baseRandom(0, length - 1)] : undefined;
2463 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2480 * Gets the index at which the `key` is found in `array` of key-value pairs.
2485 * @returns {number} Returns the index of the matched value, else `-1`.
2489 while (length--) {
2494 return -1;
2572 var index = -1,
2611 * 1 - Deep clone
2612 * 2 - Flatten inherited properties
2613 * 4 - Clone symbols
2724 while (length--) {
2765 var index = -1,
2795 while (valuesIndex--) {
2858 var index = -1,
2877 * The base implementation of `_.fill` without an iteratee call guard.
2891 start = -start > length ? 0 : (length + start);
2934 var index = -1,
2945 baseFlatten(value, depth - 1, predicate, isStrict, result);
3141 while (othIndex--) {
3153 var index = -1,
3167 while (--othIndex) {
3261 * 1 - Unordered comparison
3262 * 2 - Partial comparison
3366 while (index--) {
3539 var index = -1,
3722 var index = -1;
3762 var index = -1,
3803 index = -1,
3818 while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
3839 lastIndex = length - 1;
3841 while (length--) {
3857 * floating-point numbers.
3865 return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
3880 var index = -1,
3881 length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
3884 while (length--) {
3924 * @param {number} [start=func.length-1] The start position of the rest parameter.
3971 var index = -1,
3973 lastIndex = length - 1,
4037 * The base implementation of `_.slice` without an iteratee call guard.
4046 var index = -1,
4050 start = -start > length ? 0 : (length + start);
4056 length = start > end ? 0 : ((end - start) >>> 0);
4181 var index = -1,
4237 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4250 var index = -1,
4281 while (seenIndex--) {
4342 index = fromRight ? length : -1;
4344 while ((fromRight ? index-- : ++index < length) &&
4387 var index = -1,
4392 othIndex = -1;
4413 var index = -1,
4430 * @returns {Array|Object} Returns the cast array-like object.
4612 return -1;
4633 var index = -1,
4646 return result * (order == 'desc' ? -1 : 1);
4656 return object.index - other.index;
4671 var argsIndex = -1,
4674 leftIndex = -1,
4676 rangeLength = nativeMax(argsLength - holdersLength, 0),
4688 while (rangeLength--) {
4706 var argsIndex = -1,
4708 holdersIndex = -1,
4710 rightIndex = -1,
4712 rangeLength = nativeMax(argsLength - holdersLength, 0),
4740 var index = -1,
4764 var index = -1,
4836 var index = -1,
4838 customizer = length > 1 ? sources[length - 1] : undefined,
4839 guard = length > 2 ? sources[2] : undefined;
4842 ? (length--, customizer)
4845 if (guard && isIterateeCall(sources[0], sources[1], guard)) {
4877 index = fromRight ? length : -1,
4880 while ((fromRight ? index-- : ++index < length)) {
4898 var index = -1,
4903 while (length--) {
4985 …// http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-a…
5025 while (index--) {
5028 var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
5032 length -= holders.length;
5036 args, holders, undefined, undefined, arity - length);
5060 return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
5080 while (index--) {
5157 while (index--) {
5170 length -= holdersCount;
5175 args, newHolders, argPos, ary, arity - length
5304 var argsIndex = -1,
5306 leftIndex = -1,
5314 while (argsLength--) {
5334 // Ensure the sign of `-0` is preserved.
5342 step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
5420 // Shift with exponential notation to avoid floating-point issues.
5426 return +(pair[0] + 'e' + (+pair[1] - precision));
5439 …var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values…
5470 * 1 - `_.bind`
5471 * 2 - `_.bindKey`
5472 * 4 - `_.curry` or `_.curryRight` of a bound function
5473 * 8 - `_.curry`
5474 * 16 - `_.curryRight`
5475 * 32 - `_.partial`
5476 * 64 - `_.partialRight`
5477 * 128 - `_.rearg`
5478 * 256 - `_.ary`
5479 * 512 - `_.flip`
5500 length -= holders ? holders.length : 0;
5525 : nativeMax(newData[9] - length, 0);
5626 var index = -1,
5633 // Ignore non-index properties.
5721 … // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
5780 while (index--) {
5890 while (length--) {
5955 while (length--) {
6081 var index = -1,
6090 case 'dropRight': end -= size; break;
6092 case 'takeRight': start = nativeMax(start, end - size); break;
6122 var index = -1,
6234 var lastIndex = length - 1;
6253 * Checks if `value` is a valid array-like index.
6267 (value > -1 && value % 1 == 0 && value < length);
6509 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
6542 * @param {number} [start=func.length-1] The start position of the rest parameter.
6547 start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
6550 index = -1,
6551 length = nativeMax(args.length - start, 0),
6557 index = -1;
6576 return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
6594 while (length--) {
6689 remaining = HOT_SPAN - (stamp - lastCalled);
6712 var index = -1,
6714 lastIndex = length - 1;
6758 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
6816 /*------------------------------------------------------------------------*/
6829 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
6839 function chunk(array, size, guard) { argument
6840 if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
6875 var index = -1,
6916 var args = Array(length - 1),
6920 while (index--) {
6921 args[index - 1] = arguments[index];
6928 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7031 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7047 function drop(array, n, guard) { argument
7052 n = (guard || n === undefined) ? 1 : toInteger(n);
7065 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7081 function dropRight(array, n, guard) { argument
7086 n = (guard || n === undefined) ? 1 : toInteger(n);
7087 n = length - n;
7225 * @returns {number} Returns the index of the found element, else `-1`.
7252 return -1;
7271 * @param {number} [fromIndex=array.length-1] The index to search from.
7272 * @returns {number} Returns the index of the found element, else `-1`.
7299 return -1;
7301 var index = length - 1;
7306 : nativeMin(index, length - 1);
7380 * from key-value `pairs`.
7386 * @param {Array} pairs The key-value pairs.
7394 var index = -1,
7429 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7440 * @returns {number} Returns the index of the matched value, else `-1`.
7453 return -1;
7478 return length ? baseSlice(array, 0, -1) : [];
7483 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7611 return length ? array[length - 1] : undefined;
7624 * @param {number} [fromIndex=array.length-1] The index to search from.
7625 * @returns {number} Returns the index of the matched value, else `-1`.
7638 return -1;
7643 index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
7668 * _.nth(array, -2);
7677 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7852 var index = -1,
7987 * @returns {number} Returns the index of the matched value, else `-1`.
8001 return -1;
8065 * @returns {number} Returns the index of the matched value, else `-1`.
8074 var index = baseSortedIndex(array, value, true) - 1;
8079 return -1;
8153 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8169 function take(array, n, guard) { argument
8173 n = (guard || n === undefined) ? 1 : toInteger(n);
8186 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8202 function takeRight(array, n, guard) { argument
8207 n = (guard || n === undefined) ? 1 : toInteger(n);
8208 n = length - n;
8296 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8373 * Creates a duplicate-free version of an array, using
8374 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8448 * elements and creates an array regrouping the elements to their pre-zip
8517 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8700 iteratee = length > 1 ? arrays[length - 1] : undefined;
8706 /*------------------------------------------------------------------------*/
9053 /*------------------------------------------------------------------------*/
9101 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9126 function every(collection, predicate, guard) { argument
9128 if (guard && isIterateeCall(collection, predicate, guard)) {
9224 * @param {number} [fromIndex=collection.length-1] The index to search from.
9404 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
9415 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
9431 function includes(collection, value, fromIndex, guard) { argument
9433 fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;
9440 ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
9441 : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
9468 var index = -1,
9571 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
9586 function orderBy(collection, iteratees, orders, guard) { argument
9593 orders = guard ? undefined : orders;
9781 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9791 function sampleSize(collection, n, guard) { argument
9792 if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
9803 * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
9822 * Gets the size of `collection` by returning its length for array-like
9867 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9892 function some(collection, predicate, guard) { argument
9894 if (guard && isIterateeCall(collection, predicate, guard)) {
9942 /*------------------------------------------------------------------------*/
9956 * console.log(_.now() - stamp);
9964 /*------------------------------------------------------------------------*/
9996 if (--n < 1) {
10012 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10019 function ary(func, n, guard) { argument
10020 n = guard ? undefined : n;
10049 if (--n > 0) {
10109 * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
10175 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10198 function curry(func, arity, guard) { argument
10199 arity = guard ? undefined : arity;
10220 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10243 function curryRight(func, arity, guard) { argument
10244 arity = guard ? undefined : arity;
10268 … * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
10347 var timeSinceLastCall = time - lastCallTime,
10348 timeSinceLastInvoke = time - lastInvokeTime,
10349 timeWaiting = wait - timeSinceLastCall;
10352 ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
10357 var timeSinceLastCall = time - lastCallTime,
10358 timeSinceLastInvoke = time - lastInvokeTime;
10506 … * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
10659 var index = -1,
10783 * @param {number} [start=func.length-1] The start position of the rest parameter.
10806 …* [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
10870 … * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
10960 /*------------------------------------------------------------------------*/
11154 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
11308 * Checks if `value` is array-like. A value is considered array-like if it's
11317 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
11345 * @returns {boolean} Returns `true` if `value` is an array-like object,
11452 * Array-like values such as `arguments` objects, arrays, buffers, strings, or
11453 * jQuery-like collections are considered empty if they have a `length` of `0`.
11688 * Checks if `value` is a valid array-like length.
11691 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
11715 value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
11720 … * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
11721 … * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
11749 * Checks if `value` is object-like. A value is object-like if it's not `null`
11757 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
11870 * `undefined` and other non-number values.
11903 * of the core-js package because core-js circumvents this kind of detection.
11904 * Despite multiple requests, the core-js maintainer has made it clear: any
11907 * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
11908 * which rely on core-js.
11980 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
12069 * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
12096 return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
12350 * // => 5e-324
12363 if (value === INFINITY || value === -INFINITY) {
12364 var sign = (value < 0 ? -1 : 1);
12374 * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
12400 return result === result ? (remainder ? result - remainder : result) : 0;
12405 * array-like object.
12408 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
12449 * // => 5e-324
12532 ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
12538 * and `undefined` values. The sign of `-0` is preserved.
12551 * _.toString(-0);
12552 * // => '-0'
12561 /*------------------------------------------------------------------------*/
12789 var index = -1;
12791 var guard = length > 2 ? sources[2] : undefined;
12793 if (guard && isIterateeCall(sources[0], sources[1], guard)) {
12800 var propsIndex = -1;
13281 * **Note:** Non-object values are coerced to objects. See the
13282 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
13313 * **Note:** Non-object values are coerced to objects.
13512 while (length--) {
13626 var index = -1,
13707 * Creates an array of own enumerable string keyed-value pairs for `object`
13717 * @returns {Array} Returns the key-value pairs.
13733 * Creates an array of own and inherited enumerable string keyed-value pairs
13743 * @returns {Array} Returns the key-value pairs.
13905 * **Note:** Non-object values are coerced to objects.
13936 * **Note:** Non-object values are coerced to objects.
13960 /*------------------------------------------------------------------------*/
13975 * _.clamp(-10, -5, 5);
13976 * // => -5
13978 * _.clamp(10, -5, 5);
14032 * _.inRange(-3, -2, -6);
14051 * floats, a floating-point number is returned instead of an integer.
14053 * **Note:** JavaScript follows the IEEE-754 standard for resolving
14054 * floating-point values which can produce unexpected results.
14062 * @param {boolean} [floating] Specify returning a floating-point number.
14073 * // => a floating-point number between 0 and 5
14076 * // => a floating-point number between 1.2 and 5.2
14112 …return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1))…
14117 /*------------------------------------------------------------------------*/
14133 * _.camelCase('--foo-bar--');
14165 …* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_…
14166 * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
14219 position -= target.length;
14228 * characters use a third-party library like [_he_](https://mths.be/he).
14233 * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
14234 * (under "semi-related fun fact") for more details.
14237 * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
14293 * // => 'foo-bar'
14296 * // => 'foo-bar'
14299 * // => 'foo-bar'
14302 return result + (index ? '-' : '') + word.toLowerCase();
14316 * _.lowerCase('--Foo-Bar--');
14365 * _.pad('abc', 8, '_-');
14366 * // => '_-abc_-_'
14379 var mid = (length - strLength) / 2;
14404 * _.padEnd('abc', 6, '_-');
14405 * // => 'abc_-_'
14416 ? (string + createPadding(length - strLength, chars))
14437 * _.padStart('abc', 6, '_-');
14438 * // => '_-_abc'
14449 ? (createPadding(length - strLength, chars) + string)
14467 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14477 function parseInt(string, radix, guard) { argument
14478 if (guard || radix == null) {
14495 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14508 function repeat(string, n, guard) { argument
14509 if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
14561 * _.snakeCase('--FOO-BAR--');
14584 * _.split('a-b-c', '-', 2);
14620 * _.startCase('--foo-bar--');
14668 * in "interpolate" delimiters, HTML-escape interpolated data properties in
14674 * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
14678 * [lodash's custom builds documentation](https://lodash.com/custom-builds).
14701 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14711 * var compiled = _.template('<b><%- value %></b>');
14716 …* var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>'…
14732 * var compiled = _.template('<%= "\\<%- value %\\>" %>');
14734 * // => '<%- value %>'
14737 * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
14747 * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
14757 * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
14770 function template(string, options, guard) { argument
14772 // (http://ejohn.org/blog/javascript-micro-templating/)
14776 if (guard && isIterateeCall(string, options, guard)) {
14798 , 'g');
14801 // The sourceURL gets injected into the source that's eval-ed, so be careful
14802 // with lookup (in case of e.g. prototype pollution), and strip newlines if any.
14806 ? (options.sourceURL + '').replace(/[\r\n]/g, ' ')
14837 // If `variable` is not specified wrap a with-statement around the generated
14895 * _.toLower('--Foo-Bar--');
14896 * // => '--foo-bar--'
14920 * _.toUpper('--foo-bar--');
14921 * // => '--FOO-BAR--'
14942 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14949 * _.trim('-_-abc-_-', '_-');
14955 function trim(string, chars, guard) { argument
14957 if (string && (guard || chars === undefined)) {
14980 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14987 * _.trimEnd('-_-abc-_-', '_-');
14988 * // => '-_-abc'
14990 function trimEnd(string, chars, guard) { argument
14992 if (string && (guard || chars === undefined)) {
15013 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15020 * _.trimStart('-_-abc-_-', '_-');
15021 * // => 'abc-_-'
15023 function trimStart(string, chars, guard) { argument
15025 if (string && (guard || chars === undefined)) {
15054 * _.truncate('hi-diddly-ho there, neighborino');
15055 * // => 'hi-diddly-ho there, neighbo...'
15057 * _.truncate('hi-diddly-ho there, neighborino', {
15061 * // => 'hi-diddly-ho there,...'
15063 * _.truncate('hi-diddly-ho there, neighborino', {
15067 * // => 'hi-diddly-ho there...'
15069 * _.truncate('hi-diddly-ho there, neighborino', {
15072 * // => 'hi-diddly-ho there, neig [...]'
15093 var end = length - stringSize(omission);
15105 end += (result.length - end);
15113 separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
15123 if (index > -1) {
15136 * HTML entities use a third-party library like [_he_](https://mths.be/he).
15167 * _.upperCase('--foo-bar');
15208 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15215 * _.words('fred, barney, & pebbles', /[^, ]+/g);
15218 function words(string, pattern, guard) { argument
15220 pattern = guard ? undefined : pattern;
15228 /*------------------------------------------------------------------------*/
15296 * function of the first predicate to return truthy. The predicate-function
15304 * @param {Array} pairs The predicate-function pairs.
15335 var index = -1;
15773 * @returns {Function} Returns the new pass-thru function.
15780 * var func = _.nthArg(-2);
15918 * `start` up to, but not including, `end`. A step of `-1` is used if a negative
15922 * **Note:** JavaScript follows the IEEE-754 standard for resolving
15923 * floating-point values which can produce unexpected results.
15939 * _.range(-4);
15940 * // => [0, -1, -2, -3]
15948 * _.range(0, -4, -1);
15949 * // => [0, -1, -2, -3]
15977 * _.rangeRight(-4);
15978 * // => [-3, -2, -1, 0]
15986 * _.rangeRight(0, -4, -1);
15987 * // => [-3, -2, -1, 0]
16120 n -= MAX_ARRAY_LENGTH;
16175 /*------------------------------------------------------------------------*/
16214 * _.ceil(6040, -2);
16256 * _.floor(4060, -2);
16449 * _.round(4060, -2);
16470 return minuend - subtrahend;
16522 /*------------------------------------------------------------------------*/
16684 /*------------------------------------------------------------------------*/
16852 /*------------------------------------------------------------------------*/
16960 result = result.takeRight(-start);
16966 result = end < 0 ? result.dropRight(-end) : result.take(end - start);
17082 /*--------------------------------------------------------------------------*/