/**

* @license

* Lodash <https://lodash.com/>

* Copyright OpenJS Foundation and other contributors <https://openjsf.org/>

* Released under MIT license <https://lodash.com/license>

* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>

* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

*/

;(function() {

/** Used as a safe reference for `undefined` in pre-ES5 environments. */

var undefined;

/** Used as the semantic version number. */

var VERSION = '4.17.21';

/** Used as the size to enable large array optimizations. */

var LARGE_ARRAY_SIZE = 200;

/** Error message constants. */

var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',

FUNC_ERROR_TEXT = 'Expected a function',

INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';

/** Used to stand-in for `undefined` hash values. */

var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used as the maximum memoize cache size. */

var MAX_MEMOIZE_SIZE = 500;

/** Used as the internal argument placeholder. */

var PLACEHOLDER = '__lodash_placeholder__';

/** Used to compose bitmasks for cloning. */

var CLONE_DEEP_FLAG = 1,

CLONE_FLAT_FLAG = 2,

CLONE_SYMBOLS_FLAG = 4;

/** Used to compose bitmasks for value comparisons. */

var COMPARE_PARTIAL_FLAG = 1,

COMPARE_UNORDERED_FLAG = 2;

/** Used to compose bitmasks for function metadata. */

var WRAP_BIND_FLAG = 1,

WRAP_BIND_KEY_FLAG = 2,

WRAP_CURRY_BOUND_FLAG = 4,

WRAP_CURRY_FLAG = 8,

WRAP_CURRY_RIGHT_FLAG = 16,

WRAP_PARTIAL_FLAG = 32,

WRAP_PARTIAL_RIGHT_FLAG = 64,

WRAP_ARY_FLAG = 128,

WRAP_REARG_FLAG = 256,

WRAP_FLIP_FLAG = 512;

/** Used as default options for `_.truncate`. */

var DEFAULT_TRUNC_LENGTH = 30,

DEFAULT_TRUNC_OMISSION = '...';

/** Used to detect hot functions by number of calls within a span of milliseconds. */

var HOT_COUNT = 800,

HOT_SPAN = 16;

/** Used to indicate the type of lazy iteratees. */

var LAZY_FILTER_FLAG = 1,

LAZY_MAP_FLAG = 2,

LAZY_WHILE_FLAG = 3;

/** Used as references for various `Number` constants. */

var INFINITY = 1 / 0,

MAX_SAFE_INTEGER = 9007199254740991,

MAX_INTEGER = 1.7976931348623157e+308,

NAN = 0 / 0;

/** Used as references for the maximum length and index of an array. */

var MAX_ARRAY_LENGTH = 4294967295,

MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,

HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

/** Used to associate wrap methods with their bit flags. */

var wrapFlags = [

['ary', WRAP_ARY_FLAG],

['bind', WRAP_BIND_FLAG],

['bindKey', WRAP_BIND_KEY_FLAG],

['curry', WRAP_CURRY_FLAG],

['curryRight', WRAP_CURRY_RIGHT_FLAG],

['flip', WRAP_FLIP_FLAG],

['partial', WRAP_PARTIAL_FLAG],

['partialRight', WRAP_PARTIAL_RIGHT_FLAG],

['rearg', WRAP_REARG_FLAG]

];

/** `Object#toString` result references. */

var argsTag = '[object Arguments]',

arrayTag = '[object Array]',

asyncTag = '[object AsyncFunction]',

boolTag = '[object Boolean]',

dateTag = '[object Date]',

domExcTag = '[object DOMException]',

errorTag = '[object Error]',

funcTag = '[object Function]',

genTag = '[object GeneratorFunction]',

mapTag = '[object Map]',

numberTag = '[object Number]',

nullTag = '[object Null]',

objectTag = '[object Object]',

promiseTag = '[object Promise]',

proxyTag = '[object Proxy]',

regexpTag = '[object RegExp]',

setTag = '[object Set]',

stringTag = '[object String]',

symbolTag = '[object Symbol]',

undefinedTag = '[object Undefined]',

weakMapTag = '[object WeakMap]',

weakSetTag = '[object WeakSet]';

var arrayBufferTag = '[object ArrayBuffer]',

dataViewTag = '[object DataView]',

float32Tag = '[object Float32Array]',

float64Tag = '[object Float64Array]',

int8Tag = '[object Int8Array]',

int16Tag = '[object Int16Array]',

int32Tag = '[object Int32Array]',

uint8Tag = '[object Uint8Array]',

uint8ClampedTag = '[object Uint8ClampedArray]',

uint16Tag = '[object Uint16Array]',

uint32Tag = '[object Uint32Array]';

/** Used to match empty string literals in compiled template source. */

var reEmptyStringLeading = /\b__p \+= '';/g,

reEmptyStringMiddle = /\b(__p \+=) '' \+/g,

reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

/** Used to match HTML entities and HTML characters. */

var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,

reUnescapedHtml = /[&<>"']/g,

reHasEscapedHtml = RegExp(reEscapedHtml.source),

reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

/** Used to match template delimiters. */

var reEscape = /<%-([\s\S]+?)%>/g,

reEvaluate = /<%([\s\S]+?)%>/g,

reInterpolate = /<%=([\s\S]+?)%>/g;

/** Used to match property names within property paths. */

var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,

reIsPlainProp = /^\w*$/,

rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

/**

* Used to match `RegExp`

* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).

*/

var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,

reHasRegExpChar = RegExp(reRegExpChar.source);

/** Used to match leading whitespace. */

var reTrimStart = /^\s+/;

/** Used to match a single whitespace character. */

var reWhitespace = /\s/;

/** Used to match wrap detail comments. */

var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,

reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,

reSplitDetails = /,? & /;

/** Used to match words composed of alphanumeric characters. */

var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

/**

* Used to validate the `validate` option in `_.template` variable.

*

* Forbids characters which could potentially change the meaning of the function argument definition:

* - "()," (modification of function parameters)

* - "=" (default value)

* - "[]{}" (destructuring of function parameters)

* - "/" (beginning of a comment)

* - whitespace

*/

var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;

/** Used to match backslashes in property paths. */

var reEscapeChar = /\\(\\)?/g;

/**

* Used to match

* [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).

*/

var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

/** Used to match `RegExp` flags from their coerced string values. */

var reFlags = /\w*$/;

/** Used to detect bad signed hexadecimal string values. */

var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */

var reIsBinary = /^0b[01]+$/i;

/** Used to detect host constructors (Safari). */

var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect octal string values. */

var reIsOctal = /^0o[0-7]+$/i;

/** Used to detect unsigned integer values. */

var reIsUint = /^(?:0|[1-9]\d*)$/;

/** Used to match Latin Unicode letters (excluding mathematical operators). */

var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

/** Used to ensure capturing order of template delimiters. */

var reNoMatch = /($^)/;

/** Used to match unescaped characters in compiled string literals. */

var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

/** Used to compose unicode character classes. */

var rsAstralRange = '\\ud800-\\udfff',

rsComboMarksRange = '\\u0300-\\u036f',

reComboHalfMarksRange = '\\ufe20-\\ufe2f',

rsComboSymbolsRange = '\\u20d0-\\u20ff',

rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,

rsDingbatRange = '\\u2700-\\u27bf',

rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',

rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',

rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',

rsPunctuationRange = '\\u2000-\\u206f',

rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',

rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',

rsVarRange = '\\ufe0e\\ufe0f',

rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

/** Used to compose unicode capture groups. */

var rsApos = "['\u2019]",

rsAstral = '[' + rsAstralRange + ']',

rsBreak = '[' + rsBreakRange + ']',

rsCombo = '[' + rsComboRange + ']',

rsDigits = '\\d+',

rsDingbat = '[' + rsDingbatRange + ']',

rsLower = '[' + rsLowerRange + ']',

rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',

rsFitz = '\\ud83c[\\udffb-\\udfff]',

rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',

rsNonAstral = '[^' + rsAstralRange + ']',

rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',

rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',

rsUpper = '[' + rsUpperRange + ']',

rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */

var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',

rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',

rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',

rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',

reOptMod = rsModifier + '?',

rsOptVar = '[' + rsVarRange + ']?',

rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',

rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',

rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',

rsSeq = rsOptVar + reOptMod + rsOptJoin,

rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,

rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

/** Used to match apostrophes. */

var reApos = RegExp(rsApos, 'g');

/**

* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).

*/

var reComboMark = RegExp(rsCombo, 'g');

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */

var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

/** Used to match complex or compound words. */

var reUnicodeWord = RegExp([

rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',

rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',

rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,

rsUpper + '+' + rsOptContrUpper,

rsOrdUpper,

rsOrdLower,

rsDigits,

rsEmoji

].join('|'), 'g');

/** 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/). */

var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');

/** Used to detect strings that need a more robust regexp to match words. */

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 ]/;

/** Used to assign default `context` object properties. */

var contextProps = [

'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',

'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',

'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',

'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',

'_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'

];

/** Used to make template sourceURLs easier to identify. */

var templateCounter = -1;

/** Used to identify `toStringTag` values of typed arrays. */

var typedArrayTags = {};

typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

typedArrayTags[uint32Tag] = true;

typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =

typedArrayTags[errorTag] = typedArrayTags[funcTag] =

typedArrayTags[mapTag] = typedArrayTags[numberTag] =

typedArrayTags[objectTag] = typedArrayTags[regexpTag] =

typedArrayTags[setTag] = typedArrayTags[stringTag] =

typedArrayTags[weakMapTag] = false;

/** Used to identify `toStringTag` values supported by `_.clone`. */

var cloneableTags = {};

cloneableTags[argsTag] = cloneableTags[arrayTag] =

cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =

cloneableTags[boolTag] = cloneableTags[dateTag] =

cloneableTags[float32Tag] = cloneableTags[float64Tag] =

cloneableTags[int8Tag] = cloneableTags[int16Tag] =

cloneableTags[int32Tag] = cloneableTags[mapTag] =

cloneableTags[numberTag] = cloneableTags[objectTag] =

cloneableTags[regexpTag] = cloneableTags[setTag] =

cloneableTags[stringTag] = cloneableTags[symbolTag] =

cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

cloneableTags[errorTag] = cloneableTags[funcTag] =

cloneableTags[weakMapTag] = false;

/** Used to map Latin Unicode letters to basic Latin letters. */

var deburredLetters = {

// Latin-1 Supplement block.

'\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

'\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

'\xc7': 'C', '\xe7': 'c',

'\xd0': 'D', '\xf0': 'd',

'\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

'\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

'\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

'\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',

'\xd1': 'N', '\xf1': 'n',

'\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

'\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

'\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

'\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

'\xdd': 'Y', '\xfd': 'y', '\xff': 'y',

'\xc6': 'Ae', '\xe6': 'ae',

'\xde': 'Th', '\xfe': 'th',

'\xdf': 'ss',

// Latin Extended-A block.

'\u0100': 'A', '\u0102': 'A', '\u0104': 'A',

'\u0101': 'a', '\u0103': 'a', '\u0105': 'a',

'\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',

'\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',

'\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',

'\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',

'\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',

'\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',

'\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',

'\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',

'\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',

'\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',

'\u0134': 'J', '\u0135': 'j',

'\u0136': 'K', '\u0137': 'k', '\u0138': 'k',

'\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',

'\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',

'\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',

'\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',

'\u014c': 'O', '\u014e': 'O', '\u0150': 'O',

'\u014d': 'o', '\u014f': 'o', '\u0151': 'o',

'\u0154': 'R', '\u0156': 'R', '\u0158': 'R',

'\u0155': 'r', '\u0157': 'r', '\u0159': 'r',

'\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',

'\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',

'\u0162': 'T', '\u0164': 'T', '\u0166': 'T',

'\u0163': 't', '\u0165': 't', '\u0167': 't',

'\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',

'\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',

'\u0174': 'W', '\u0175': 'w',

'\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',

'\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',

'\u017a': 'z', '\u017c': 'z', '\u017e': 'z',

'\u0132': 'IJ', '\u0133': 'ij',

'\u0152': 'Oe', '\u0153': 'oe',

'\u0149': "'n", '\u017f': 's'

};

/** Used to map characters to HTML entities. */

var htmlEscapes = {

'&': '&amp;',

'<': '&lt;',

'>': '&gt;',

'"': '&quot;',

"'": '&#39;'

};

/** Used to map HTML entities to characters. */

var htmlUnescapes = {

'&amp;': '&',

'&lt;': '<',

'&gt;': '>',

'&quot;': '"',

'&#39;': "'"

};

/** Used to escape characters for inclusion in compiled string literals. */

var stringEscapes = {

'\\': '\\',

"'": "'",

'\n': 'n',

'\r': 'r',

'\u2028': 'u2028',

'\u2029': 'u2029'

};

/** Built-in method references without a dependency on `root`. */

var freeParseFloat = parseFloat,

freeParseInt = parseInt;

/** Detect free variable `global` from Node.js. */

var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */

var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */

var root = freeGlobal || freeSelf || Function('return this')();

/** Detect free variable `exports`. */

var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */

var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */

var moduleExports = freeModule && freeModule.exports === freeExports;

/** Detect free variable `process` from Node.js. */

var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */

var nodeUtil = (function() {

try {

// Use `util.types` for Node.js 10+.

var types = freeModule && freeModule.require && freeModule.require('util').types;

if (types) {

return types;

}

// Legacy `process.binding('util')` for Node.js < 10.

return freeProcess && freeProcess.binding && freeProcess.binding('util');

} catch (e) {}

}());

/* Node.js helper references. */

var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,

nodeIsDate = nodeUtil && nodeUtil.isDate,

nodeIsMap = nodeUtil && nodeUtil.isMap,

nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,

nodeIsSet = nodeUtil && nodeUtil.isSet,

nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/*--------------------------------------------------------------------------*/

/**

* A faster alternative to `Function#apply`, this function invokes `func`

* with the `this` binding of `thisArg` and the arguments of `args`.

*

* @private

* @param {Function} func The function to invoke.

* @param {*} thisArg The `this` binding of `func`.

* @param {Array} args The arguments to invoke `func` with.

* @returns {*} Returns the result of `func`.

*/

function apply(func, thisArg, args) {

}

/**

* A specialized version of `baseAggregator` for arrays.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} setter The function to set `accumulator` values.

* @param {Function} iteratee The iteratee to transform keys.

* @param {Object} accumulator The initial aggregated object.

* @returns {Function} Returns `accumulator`.

*/

function arrayAggregator(array, setter, iteratee, accumulator) {

}

/**

* A specialized version of `_.forEach` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @returns {Array} Returns `array`.

*/

function arrayEach(array, iteratee) {

}

/**

* A specialized version of `_.forEachRight` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @returns {Array} Returns `array`.

*/

function arrayEachRight(array, iteratee) {

}

/**

* A specialized version of `_.every` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} predicate The function invoked per iteration.

* @returns {boolean} Returns `true` if all elements pass the predicate check,

* else `false`.

*/

function arrayEvery(array, predicate) {

}

/**

* A specialized version of `_.filter` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} predicate The function invoked per iteration.

* @returns {Array} Returns the new filtered array.

*/

function arrayFilter(array, predicate) {

}

/**

* A specialized version of `_.includes` for arrays without support for

* specifying an index to search from.

*

* @private

* @param {Array} [array] The array to inspect.

* @param {*} target The value to search for.

* @returns {boolean} Returns `true` if `target` is found, else `false`.

*/

function arrayIncludes(array, value) {

var length = array == null ? 0 : array.length;

return !!length && baseIndexOf(array, value, 0) > -1;

}

/**

* This function is like `arrayIncludes` except that it accepts a comparator.

*

* @private

* @param {Array} [array] The array to inspect.

* @param {*} target The value to search for.

* @param {Function} comparator The comparator invoked per element.

* @returns {boolean} Returns `true` if `target` is found, else `false`.

*/

function arrayIncludesWith(array, value, comparator) {

}

/**

* A specialized version of `_.map` for arrays without support for iteratee

* shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @returns {Array} Returns the new mapped array.

*/

function arrayMap(array, iteratee) {

}

/**

* Appends the elements of `values` to `array`.

*

* @private

* @param {Array} array The array to modify.

* @param {Array} values The values to append.

* @returns {Array} Returns `array`.

*/

function arrayPush(array, values) {

}

/**

* A specialized version of `_.reduce` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @param {*} [accumulator] The initial value.

* @param {boolean} [initAccum] Specify using the first element of `array` as

* the initial value.

* @returns {*} Returns the accumulated value.

*/

function arrayReduce(array, iteratee, accumulator, initAccum) {

}

/**

* A specialized version of `_.reduceRight` for arrays without support for

* iteratee shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @param {*} [accumulator] The initial value.

* @param {boolean} [initAccum] Specify using the last element of `array` as

* the initial value.

* @returns {*} Returns the accumulated value.

*/

function arrayReduceRight(array, iteratee, accumulator, initAccum) {

}

/**

* A specialized version of `_.some` for arrays without support for iteratee

* shorthands.

*

* @private

* @param {Array} [array] The array to iterate over.

* @param {Function} predicate The function invoked per iteration.

* @returns {boolean} Returns `true` if any element passes the predicate check,

* else `false`.

*/

function arraySome(array, predicate) {

}

/**

* Gets the size of an ASCII `string`.

*

* @private

* @param {string} string The string inspect.

* @returns {number} Returns the string size.

*/

var asciiSize = baseProperty('length');

/**

* Converts an ASCII `string` to an array.

*

* @private

* @param {string} string The string to convert.

* @returns {Array} Returns the converted array.

*/

function asciiToArray(string) {

return string.split('');

}

/**

* Splits an ASCII `string` into an array of its words.

*

* @private

* @param {string} The string to inspect.

* @returns {Array} Returns the words of `string`.

*/

function asciiWords(string) {

return string.match(reAsciiWord) || [];

}

/**

* The base implementation of methods like `_.findKey` and `_.findLastKey`,

* without support for iteratee shorthands, which iterates over `collection`

* using `eachFunc`.

*

* @private

* @param {Array|Object} collection The collection to inspect.

* @param {Function} predicate The function invoked per iteration.

* @param {Function} eachFunc The function to iterate over `collection`.

* @returns {*} Returns the found element or its key, else `undefined`.

*/

function baseFindKey(collection, predicate, eachFunc) {

}

/**

* The base implementation of `_.findIndex` and `_.findLastIndex` without

* support for iteratee shorthands.

*

* @private

* @param {Array} array The array to inspect.

* @param {Function} predicate The function invoked per iteration.

* @param {number} fromIndex The index to search from.

* @param {boolean} [fromRight] Specify iterating from right to left.

* @returns {number} Returns the index of the matched value, else `-1`.

*/

function baseFindIndex(array, predicate, fromIndex, fromRight) {

}

/**

* The base implementation of `_.indexOf` without `fromIndex` bounds checks.

*

* @private

* @param {Array} array The array to inspect.

* @param {*} value The value to search for.

* @param {number} fromIndex The index to search from.

* @returns {number} Returns the index of the matched value, else `-1`.

*/

function baseIndexOf(array, value, fromIndex) {

}

/**

* This function is like `baseIndexOf` except that it accepts a comparator.

*

* @private

* @param {Array} array The array to inspect.

* @param {*} value The value to search for.

* @param {number} fromIndex The index to search from.

* @param {Function} comparator The comparator invoked per element.

* @returns {number} Returns the index of the matched value, else `-1`.

*/

function baseIndexOfWith(array, value, fromIndex, comparator) {

}

/**

* The base implementation of `_.isNaN` without support for number objects.

*

* @private

* @param {*} value The value to check.

* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.

*/

function baseIsNaN(value) {

return value !== value;

}

/**

* The base implementation of `_.mean` and `_.meanBy` without support for

* iteratee shorthands.

*

* @private

* @param {Array} array The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @returns {number} Returns the mean.

*/

function baseMean(array, iteratee) {

var length = array == null ? 0 : array.length;

return length ? (baseSum(array, iteratee) / length) : NAN;

}

/**

* The base implementation of `_.property` without support for deep paths.

*

* @private

* @param {string} key The key of the property to get.

* @returns {Function} Returns the new accessor function.

*/

function baseProperty(key) {

}

/**

* The base implementation of `_.propertyOf` without support for deep paths.

*

* @private

* @param {Object} object The object to query.

* @returns {Function} Returns the new accessor function.

*/

function basePropertyOf(object) {

}

/**

* The base implementation of `_.reduce` and `_.reduceRight`, without support

* for iteratee shorthands, which iterates over `collection` using `eachFunc`.

*

* @private

* @param {Array|Object} collection The collection to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @param {*} accumulator The initial value.

* @param {boolean} initAccum Specify using the first or last element of

* `collection` as the initial value.

* @param {Function} eachFunc The function to iterate over `collection`.

* @returns {*} Returns the accumulated value.

*/

function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {

}

/**

* The base implementation of `_.sortBy` which uses `comparer` to define the

* sort order of `array` and replaces criteria objects with their corresponding

* values.

*

* @private

* @param {Array} array The array to sort.

* @param {Function} comparer The function to define sort order.

* @returns {Array} Returns `array`.

*/

function baseSortBy(array, comparer) {

}

/**

* The base implementation of `_.sum` and `_.sumBy` without support for

* iteratee shorthands.

*

* @private

* @param {Array} array The array to iterate over.

* @param {Function} iteratee The function invoked per iteration.

* @returns {number} Returns the sum.

*/

function baseSum(array, iteratee) {

}

/**

* The base implementation of `_.times` without support for iteratee shorthands

* or max array length checks.

*

* @private

* @param {number} n The number of times to invoke `iteratee`.

* @param {Function} iteratee The function invoked per iteration.

* @returns {Array} Returns the array of results.

*/

function baseTimes(n, iteratee) {

}

/**

* The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array

* of key-value pairs for `object` corresponding to the property names of `props`.

*

* @private

* @param {Object} object The object to query.