1  /**
  2   * lodash (Custom Build) <https://lodash.com/>
  3   * Build: `lodash modularize exports="npm" -o ./`
  4   * Copyright jQuery Foundation and other contributors <https://jquery.org/>
  5   * Released under MIT license <https://lodash.com/license>
  6   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  7   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  8   */
  9  
 10  /** Used as default options for `_.truncate`. */
 11  var DEFAULT_TRUNC_LENGTH = 30,
 12      DEFAULT_TRUNC_OMISSION = '...';
 13  
 14  /** Used as references for various `Number` constants. */
 15  var INFINITY = 1 / 0,
 16      MAX_INTEGER = 1.7976931348623157e+308,
 17      NAN = 0 / 0;
 18  
 19  /** `Object#toString` result references. */
 20  var regexpTag = '[object RegExp]',
 21      symbolTag = '[object Symbol]';
 22  
 23  /** Used to match leading and trailing whitespace. */
 24  var reTrim = /^\s+|\s+$/g;
 25  
 26  /** Used to match `RegExp` flags from their coerced string values. */
 27  var reFlags = /\w*$/;
 28  
 29  /** Used to detect bad signed hexadecimal string values. */
 30  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
 31  
 32  /** Used to detect binary string values. */
 33  var reIsBinary = /^0b[01]+$/i;
 34  
 35  /** Used to detect octal string values. */
 36  var reIsOctal = /^0o[0-7]+$/i;
 37  
 38  /** Used to compose unicode character classes. */
 39  var rsAstralRange = '\\ud800-\\udfff',
 40      rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
 41      rsComboSymbolsRange = '\\u20d0-\\u20f0',
 42      rsVarRange = '\\ufe0e\\ufe0f';
 43  
 44  /** Used to compose unicode capture groups. */
 45  var rsAstral = '[' + rsAstralRange + ']',
 46      rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
 47      rsFitz = '\\ud83c[\\udffb-\\udfff]',
 48      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
 49      rsNonAstral = '[^' + rsAstralRange + ']',
 50      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
 51      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
 52      rsZWJ = '\\u200d';
 53  
 54  /** Used to compose unicode regexes. */
 55  var reOptMod = rsModifier + '?',
 56      rsOptVar = '[' + rsVarRange + ']?',
 57      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
 58      rsSeq = rsOptVar + reOptMod + rsOptJoin,
 59      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
 60  
 61  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
 62  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
 63  
 64  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
 65  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
 66  
 67  /** Built-in method references without a dependency on `root`. */
 68  var freeParseInt = parseInt;
 69  
 70  /** Detect free variable `global` from Node.js. */
 71  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
 72  
 73  /** Detect free variable `self`. */
 74  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
 75  
 76  /** Used as a reference to the global object. */
 77  var root = freeGlobal || freeSelf || Function('return this')();
 78  
 79  /** Detect free variable `exports`. */
 80  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
 81  
 82  /** Detect free variable `module`. */
 83  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
 84  
 85  /** Detect the popular CommonJS extension `module.exports`. */
 86  var moduleExports = freeModule && freeModule.exports === freeExports;
 87  
 88  /** Detect free variable `process` from Node.js. */
 89  var freeProcess = moduleExports && freeGlobal.process;
 90  
 91  /** Used to access faster Node.js helpers. */
 92  var nodeUtil = (function() {
 93    try {
 94      return freeProcess && freeProcess.binding('util');
 95    } catch (e) {}
 96  }());
 97  
 98  /* Node.js helper references. */
 99  var nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;
100  
101  /**
102   * Gets the size of an ASCII `string`.
103   *
104   * @private
105   * @param {string} string The string inspect.
106   * @returns {number} Returns the string size.
107   */
108  var asciiSize = baseProperty('length');
109  
110  /**
111   * Converts an ASCII `string` to an array.
112   *
113   * @private
114   * @param {string} string The string to convert.
115   * @returns {Array} Returns the converted array.
116   */
117  function asciiToArray(string) {
118    return string.split('');
119  }
120  
121  /**
122   * The base implementation of `_.property` without support for deep paths.
123   *
124   * @private
125   * @param {string} key The key of the property to get.
126   * @returns {Function} Returns the new accessor function.
127   */
128  function baseProperty(key) {
129    return function(object) {
130      return object == null ? undefined : object[key];
131    };
132  }
133  
134  /**
135   * The base implementation of `_.unary` without support for storing metadata.
136   *
137   * @private
138   * @param {Function} func The function to cap arguments for.
139   * @returns {Function} Returns the new capped function.
140   */
141  function baseUnary(func) {
142    return function(value) {
143      return func(value);
144    };
145  }
146  
147  /**
148   * Checks if `string` contains Unicode symbols.
149   *
150   * @private
151   * @param {string} string The string to inspect.
152   * @returns {boolean} Returns `true` if a symbol is found, else `false`.
153   */
154  function hasUnicode(string) {
155    return reHasUnicode.test(string);
156  }
157  
158  /**
159   * Gets the number of symbols in `string`.
160   *
161   * @private
162   * @param {string} string The string to inspect.
163   * @returns {number} Returns the string size.
164   */
165  function stringSize(string) {
166    return hasUnicode(string)
167      ? unicodeSize(string)
168      : asciiSize(string);
169  }
170  
171  /**
172   * Converts `string` to an array.
173   *
174   * @private
175   * @param {string} string The string to convert.
176   * @returns {Array} Returns the converted array.
177   */
178  function stringToArray(string) {
179    return hasUnicode(string)
180      ? unicodeToArray(string)
181      : asciiToArray(string);
182  }
183  
184  /**
185   * Gets the size of a Unicode `string`.
186   *
187   * @private
188   * @param {string} string The string inspect.
189   * @returns {number} Returns the string size.
190   */
191  function unicodeSize(string) {
192    var result = reUnicode.lastIndex = 0;
193    while (reUnicode.test(string)) {
194      result++;
195    }
196    return result;
197  }
198  
199  /**
200   * Converts a Unicode `string` to an array.
201   *
202   * @private
203   * @param {string} string The string to convert.
204   * @returns {Array} Returns the converted array.
205   */
206  function unicodeToArray(string) {
207    return string.match(reUnicode) || [];
208  }
209  
210  /** Used for built-in method references. */
211  var objectProto = Object.prototype;
212  
213  /**
214   * Used to resolve the
215   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
216   * of values.
217   */
218  var objectToString = objectProto.toString;
219  
220  /** Built-in value references. */
221  var Symbol = root.Symbol;
222  
223  /** Used to convert symbols to primitives and strings. */
224  var symbolProto = Symbol ? Symbol.prototype : undefined,
225      symbolToString = symbolProto ? symbolProto.toString : undefined;
226  
227  /**
228   * The base implementation of `_.isRegExp` without Node.js optimizations.
229   *
230   * @private
231   * @param {*} value The value to check.
232   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
233   */
234  function baseIsRegExp(value) {
235    return isObject(value) && objectToString.call(value) == regexpTag;
236  }
237  
238  /**
239   * The base implementation of `_.slice` without an iteratee call guard.
240   *
241   * @private
242   * @param {Array} array The array to slice.
243   * @param {number} [start=0] The start position.
244   * @param {number} [end=array.length] The end position.
245   * @returns {Array} Returns the slice of `array`.
246   */
247  function baseSlice(array, start, end) {
248    var index = -1,
249        length = array.length;
250  
251    if (start < 0) {
252      start = -start > length ? 0 : (length + start);
253    }
254    end = end > length ? length : end;
255    if (end < 0) {
256      end += length;
257    }
258    length = start > end ? 0 : ((end - start) >>> 0);
259    start >>>= 0;
260  
261    var result = Array(length);
262    while (++index < length) {
263      result[index] = array[index + start];
264    }
265    return result;
266  }
267  
268  /**
269   * The base implementation of `_.toString` which doesn't convert nullish
270   * values to empty strings.
271   *
272   * @private
273   * @param {*} value The value to process.
274   * @returns {string} Returns the string.
275   */
276  function baseToString(value) {
277    // Exit early for strings to avoid a performance hit in some environments.
278    if (typeof value == 'string') {
279      return value;
280    }
281    if (isSymbol(value)) {
282      return symbolToString ? symbolToString.call(value) : '';
283    }
284    var result = (value + '');
285    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
286  }
287  
288  /**
289   * Casts `array` to a slice if it's needed.
290   *
291   * @private
292   * @param {Array} array The array to inspect.
293   * @param {number} start The start position.
294   * @param {number} [end=array.length] The end position.
295   * @returns {Array} Returns the cast slice.
296   */
297  function castSlice(array, start, end) {
298    var length = array.length;
299    end = end === undefined ? length : end;
300    return (!start && end >= length) ? array : baseSlice(array, start, end);
301  }
302  
303  /**
304   * Checks if `value` is the
305   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
306   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
307   *
308   * @static
309   * @memberOf _
310   * @since 0.1.0
311   * @category Lang
312   * @param {*} value The value to check.
313   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
314   * @example
315   *
316   * _.isObject({});
317   * // => true
318   *
319   * _.isObject([1, 2, 3]);
320   * // => true
321   *
322   * _.isObject(_.noop);
323   * // => true
324   *
325   * _.isObject(null);
326   * // => false
327   */
328  function isObject(value) {
329    var type = typeof value;
330    return !!value && (type == 'object' || type == 'function');
331  }
332  
333  /**
334   * Checks if `value` is object-like. A value is object-like if it's not `null`
335   * and has a `typeof` result of "object".
336   *
337   * @static
338   * @memberOf _
339   * @since 4.0.0
340   * @category Lang
341   * @param {*} value The value to check.
342   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
343   * @example
344   *
345   * _.isObjectLike({});
346   * // => true
347   *
348   * _.isObjectLike([1, 2, 3]);
349   * // => true
350   *
351   * _.isObjectLike(_.noop);
352   * // => false
353   *
354   * _.isObjectLike(null);
355   * // => false
356   */
357  function isObjectLike(value) {
358    return !!value && typeof value == 'object';
359  }
360  
361  /**
362   * Checks if `value` is classified as a `RegExp` object.
363   *
364   * @static
365   * @memberOf _
366   * @since 0.1.0
367   * @category Lang
368   * @param {*} value The value to check.
369   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
370   * @example
371   *
372   * _.isRegExp(/abc/);
373   * // => true
374   *
375   * _.isRegExp('/abc/');
376   * // => false
377   */
378  var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
379  
380  /**
381   * Checks if `value` is classified as a `Symbol` primitive or object.
382   *
383   * @static
384   * @memberOf _
385   * @since 4.0.0
386   * @category Lang
387   * @param {*} value The value to check.
388   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
389   * @example
390   *
391   * _.isSymbol(Symbol.iterator);
392   * // => true
393   *
394   * _.isSymbol('abc');
395   * // => false
396   */
397  function isSymbol(value) {
398    return typeof value == 'symbol' ||
399      (isObjectLike(value) && objectToString.call(value) == symbolTag);
400  }
401  
402  /**
403   * Converts `value` to a finite number.
404   *
405   * @static
406   * @memberOf _
407   * @since 4.12.0
408   * @category Lang
409   * @param {*} value The value to convert.
410   * @returns {number} Returns the converted number.
411   * @example
412   *
413   * _.toFinite(3.2);
414   * // => 3.2
415   *
416   * _.toFinite(Number.MIN_VALUE);
417   * // => 5e-324
418   *
419   * _.toFinite(Infinity);
420   * // => 1.7976931348623157e+308
421   *
422   * _.toFinite('3.2');
423   * // => 3.2
424   */
425  function toFinite(value) {
426    if (!value) {
427      return value === 0 ? value : 0;
428    }
429    value = toNumber(value);
430    if (value === INFINITY || value === -INFINITY) {
431      var sign = (value < 0 ? -1 : 1);
432      return sign * MAX_INTEGER;
433    }
434    return value === value ? value : 0;
435  }
436  
437  /**
438   * Converts `value` to an integer.
439   *
440   * **Note:** This method is loosely based on
441   * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
442   *
443   * @static
444   * @memberOf _
445   * @since 4.0.0
446   * @category Lang
447   * @param {*} value The value to convert.
448   * @returns {number} Returns the converted integer.
449   * @example
450   *
451   * _.toInteger(3.2);
452   * // => 3
453   *
454   * _.toInteger(Number.MIN_VALUE);
455   * // => 0
456   *
457   * _.toInteger(Infinity);
458   * // => 1.7976931348623157e+308
459   *
460   * _.toInteger('3.2');
461   * // => 3
462   */
463  function toInteger(value) {
464    var result = toFinite(value),
465        remainder = result % 1;
466  
467    return result === result ? (remainder ? result - remainder : result) : 0;
468  }
469  
470  /**
471   * Converts `value` to a number.
472   *
473   * @static
474   * @memberOf _
475   * @since 4.0.0
476   * @category Lang
477   * @param {*} value The value to process.
478   * @returns {number} Returns the number.
479   * @example
480   *
481   * _.toNumber(3.2);
482   * // => 3.2
483   *
484   * _.toNumber(Number.MIN_VALUE);
485   * // => 5e-324
486   *
487   * _.toNumber(Infinity);
488   * // => Infinity
489   *
490   * _.toNumber('3.2');
491   * // => 3.2
492   */
493  function toNumber(value) {
494    if (typeof value == 'number') {
495      return value;
496    }
497    if (isSymbol(value)) {
498      return NAN;
499    }
500    if (isObject(value)) {
501      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
502      value = isObject(other) ? (other + '') : other;
503    }
504    if (typeof value != 'string') {
505      return value === 0 ? value : +value;
506    }
507    value = value.replace(reTrim, '');
508    var isBinary = reIsBinary.test(value);
509    return (isBinary || reIsOctal.test(value))
510      ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
511      : (reIsBadHex.test(value) ? NAN : +value);
512  }
513  
514  /**
515   * Converts `value` to a string. An empty string is returned for `null`
516   * and `undefined` values. The sign of `-0` is preserved.
517   *
518   * @static
519   * @memberOf _
520   * @since 4.0.0
521   * @category Lang
522   * @param {*} value The value to process.
523   * @returns {string} Returns the string.
524   * @example
525   *
526   * _.toString(null);
527   * // => ''
528   *
529   * _.toString(-0);
530   * // => '-0'
531   *
532   * _.toString([1, 2, 3]);
533   * // => '1,2,3'
534   */
535  function toString(value) {
536    return value == null ? '' : baseToString(value);
537  }
538  
539  /**
540   * Truncates `string` if it's longer than the given maximum string length.
541   * The last characters of the truncated string are replaced with the omission
542   * string which defaults to "...".
543   *
544   * @static
545   * @memberOf _
546   * @since 4.0.0
547   * @category String
548   * @param {string} [string=''] The string to truncate.
549   * @param {Object} [options={}] The options object.
550   * @param {number} [options.length=30] The maximum string length.
551   * @param {string} [options.omission='...'] The string to indicate text is omitted.
552   * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
553   * @returns {string} Returns the truncated string.
554   * @example
555   *
556   * _.truncate('hi-diddly-ho there, neighborino');
557   * // => 'hi-diddly-ho there, neighbo...'
558   *
559   * _.truncate('hi-diddly-ho there, neighborino', {
560   *   'length': 24,
561   *   'separator': ' '
562   * });
563   * // => 'hi-diddly-ho there,...'
564   *
565   * _.truncate('hi-diddly-ho there, neighborino', {
566   *   'length': 24,
567   *   'separator': /,? +/
568   * });
569   * // => 'hi-diddly-ho there...'
570   *
571   * _.truncate('hi-diddly-ho there, neighborino', {
572   *   'omission': ' [...]'
573   * });
574   * // => 'hi-diddly-ho there, neig [...]'
575   */
576  function truncate(string, options) {
577    var length = DEFAULT_TRUNC_LENGTH,
578        omission = DEFAULT_TRUNC_OMISSION;
579  
580    if (isObject(options)) {
581      var separator = 'separator' in options ? options.separator : separator;
582      length = 'length' in options ? toInteger(options.length) : length;
583      omission = 'omission' in options ? baseToString(options.omission) : omission;
584    }
585    string = toString(string);
586  
587    var strLength = string.length;
588    if (hasUnicode(string)) {
589      var strSymbols = stringToArray(string);
590      strLength = strSymbols.length;
591    }
592    if (length >= strLength) {
593      return string;
594    }
595    var end = length - stringSize(omission);
596    if (end < 1) {
597      return omission;
598    }
599    var result = strSymbols
600      ? castSlice(strSymbols, 0, end).join('')
601      : string.slice(0, end);
602  
603    if (separator === undefined) {
604      return result + omission;
605    }
606    if (strSymbols) {
607      end += (result.length - end);
608    }
609    if (isRegExp(separator)) {
610      if (string.slice(end).search(separator)) {
611        var match,
612            substring = result;
613  
614        if (!separator.global) {
615          separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
616        }
617        separator.lastIndex = 0;
618        while ((match = separator.exec(substring))) {
619          var newEnd = match.index;
620        }
621        result = result.slice(0, newEnd === undefined ? end : newEnd);
622      }
623    } else if (string.indexOf(baseToString(separator), end) != end) {
624      var index = result.lastIndexOf(separator);
625      if (index > -1) {
626        result = result.slice(0, index);
627      }
628    }
629    return result + omission;
630  }
631  
632  module.exports = truncate;