-
Notifications
You must be signed in to change notification settings - Fork 0
/
29107295-280e2bb5f96e96bb61cd.js.map
1 lines (1 loc) · 673 KB
/
29107295-280e2bb5f96e96bb61cd.js.map
1
{"version":3,"sources":["webpack:///./node_modules/lodash/lodash.js"],"names":["FUNC_ERROR_TEXT","PLACEHOLDER","wrapFlags","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","RegExp","source","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","rePropName","reRegExpChar","reHasRegExpChar","reTrim","reTrimStart","reTrimEnd","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reEscapeChar","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsComboRange","rsComboMarksRange","rsBreakRange","rsMathOpRange","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsMiscLower","rsMiscUpper","reOptMod","rsSeq","join","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","parseFloat","freeParseInt","parseInt","freeGlobal","global","Object","freeSelf","self","root","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","e","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","isDate","nodeIsMap","isMap","nodeIsRegExp","isRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","apply","func","thisArg","args","length","call","arrayAggregator","array","setter","iteratee","accumulator","index","value","arrayEach","arrayEachRight","arrayEvery","predicate","arrayFilter","resIndex","result","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayMap","Array","arrayPush","values","offset","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","collection","eachFunc","key","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","object","undefined","basePropertyOf","baseReduce","current","baseTimes","n","baseUnary","baseValues","props","cacheHas","cache","has","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","countHolders","placeholder","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","string","test","mapToArray","map","size","forEach","overArg","transform","arg","replaceHolders","setToArray","set","setToPairs","stringSize","lastIndex","unicodeSize","stringToArray","match","unicodeToArray","split","asciiToArray","unescapeHtmlChar","_","runInContext","context","uid","defaults","pick","Date","Error","Math","String","TypeError","arrayProto","prototype","funcProto","objectProto","coreJsData","funcToString","toString","hasOwnProperty","idCounter","maskSrcKey","exec","keys","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","replace","Buffer","Symbol","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","objectCreate","create","propertyIsEnumerable","splice","spreadableSymbol","isConcatSpreadable","symIterator","iterator","symToStringTag","toStringTag","defineProperty","getNative","ctxClearTimeout","clearTimeout","ctxNow","now","ctxSetTimeout","setTimeout","nativeCeil","ceil","nativeFloor","floor","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeIsFinite","isFinite","nativeJoin","nativeKeys","nativeMax","max","nativeMin","min","nativeNow","nativeParseInt","nativeRandom","random","nativeReverse","reverse","DataView","Map","Promise","Set","WeakMap","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","symbolToString","lodash","isObjectLike","isArray","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","proto","isObject","baseLodash","chainAll","this","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","Hash","entries","clear","entry","ListCache","MapCache","SetCache","__data__","add","Stack","data","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","push","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","copyObject","baseAt","paths","skip","get","number","lower","upper","baseClone","bitmask","customizer","stack","isDeep","isFlat","isFull","constructor","input","initCloneArray","tag","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","Ctor","cloneArrayBuffer","dataView","buffer","byteOffset","byteLength","cloneDataView","cloneTypedArray","regexp","cloneRegExp","symbol","initCloneByTag","stacked","subValue","getAllKeysIn","getAllKeys","baseConformsTo","baseDelay","wait","baseDifference","includes","isCommon","valuesLength","outer","computed","valuesIndex","templateSettings","pop","getMapData","pairs","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","isSymbol","baseFilter","baseFlatten","depth","isStrict","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","isFunction","baseGet","path","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","isOwn","unmasked","getRawTag","objectToString","baseGt","other","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","maxLength","Infinity","seen","baseInvoke","parent","last","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","name","message","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","property","baseKeys","isPrototype","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","safeGet","newValue","isTyped","isArrayLikeObject","isPlainObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","comparer","sort","baseSortBy","objCriteria","criteria","othCriteria","ordersLength","compareAscending","order","compareMultiple","basePickBy","baseSet","basePullAll","indexOf","basePullAt","indexes","previous","baseUnset","baseRepeat","baseRest","start","setToString","overRest","baseSample","baseSampleSize","nested","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","end","baseSome","baseSortedIndex","retHighest","low","high","MAX_ARRAY_LENGTH","mid","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","stringToPath","castRest","castSlice","id","slice","copy","arrayBuffer","typedArray","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","iterable","createCaseFirst","methodName","charAt","trailing","createCompounder","callback","words","deburr","createCtor","arguments","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","wrapper","getFuncName","funcName","getData","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","newHolders","createRecurry","fn","reorder","createInverter","toIteratee","baseInverter","createMathOperation","operator","defaultValue","createOver","arrayFunc","createPadding","chars","charsLength","createRange","step","toFinite","baseRange","createRelationalOperation","toNumber","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","precision","toInteger","pair","noop","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrLength","arrStacked","arrValue","flatten","otherFunc","type","getValue","stubArray","hasPath","hasFunc","isLength","ArrayBuffer","resolve","ctorString","isMaskable","stubFalse","otherArgs","oldArray","shortOut","reference","details","insertWrapDetails","updateWrapDetails","getWrapDetails","count","lastCalled","stamp","remaining","rand","memoize","memoizeCapped","charCodeAt","quote","subString","clone","difference","differenceBy","differenceWith","findIndex","findLastIndex","head","intersection","mapped","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","group","unzipWith","without","xor","xorBy","xorWith","zip","zipWith","chain","interceptor","wrapperAt","countBy","find","findLast","forEachRight","groupBy","invokeMap","keyBy","partition","sortBy","before","bind","bindKey","WRAP_BIND_FLAG","debounce","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","time","leadingEdge","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","cancel","flush","defer","delay","resolver","memoized","Cache","negate","overArgs","transforms","funcsLength","partial","partialRight","rearg","gt","gte","isError","isInteger","isNumber","isString","lt","lte","toArray","next","done","iteratorToArray","remainder","toLength","isBinary","assign","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invert","invertBy","invoke","merge","omit","CLONE_DEEP_FLAG","basePick","pickBy","prop","toPairs","toPairsIn","camelCase","word","toLowerCase","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","toUpperCase","pattern","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","method","methodOf","mixin","over","overEvery","overSome","basePropertyDeep","range","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplier","multiplicand","round","subtract","minuend","subtrahend","after","castArray","chunk","compact","concat","cond","conforms","baseConforms","properties","curry","curryRight","drop","dropRight","dropRightWhile","dropWhile","fill","baseFill","filter","flatMap","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","flip","fromPairs","functions","functionsIn","initial","mapKeys","mapValues","matches","matchesProperty","nthArg","omitBy","once","orderBy","propertyOf","pullAllBy","pullAllWith","reject","remove","rest","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","separator","limit","spread","tail","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","unset","update","updateWith","valuesIn","wrap","zipObject","zipObjectDeep","entriesIn","extend","extendWith","clamp","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","target","position","escape","escapeRegExp","every","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isElement","isEmpty","isEqual","isEqualWith","isMatch","isMatchWith","isNaN","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","lastIndexOf","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","noConflict","pad","strLength","padEnd","padStart","radix","floating","temp","reduce","reduceRight","repeat","sample","some","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","startsWith","sum","sumBy","template","settings","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trim","trimEnd","trimStart","truncate","omission","search","substring","newEnd","unescape","uniqueId","prefix","each","eachRight","first","VERSION","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","dir","isRight","view","getView","iterLength","takeCount","iterIndex","commit","wrapped","toJSON"],"mappings":"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,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAC1B,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACvE,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IACxD,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACtF,IAAU,IAAM,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IAAK,IAAU,IACtF,IAAU,IAAM,IAAU,IAC1B,IAAU,IAAM,IAAU,IAAK,IAAU,IACzC,IAAU,IAAM,IAAU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","file":"29107295-280e2bb5f96e96bb61cd.js","sourcesContent":["/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n var undefined;\n\n /** Used as the semantic version number. */\n var VERSION = '4.17.20';\n\n /** Used as the size to enable large array optimizations. */\n var LARGE_ARRAY_SIZE = 200;\n\n /** Error message constants. */\n var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n FUNC_ERROR_TEXT = 'Expected a function';\n\n /** Used to stand-in for `undefined` hash values. */\n var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n /** Used as the maximum memoize cache size. */\n var MAX_MEMOIZE_SIZE = 500;\n\n /** Used as the internal argument placeholder. */\n var PLACEHOLDER = '__lodash_placeholder__';\n\n /** Used to compose bitmasks for cloning. */\n var CLONE_DEEP_FLAG = 1,\n CLONE_FLAT_FLAG = 2,\n CLONE_SYMBOLS_FLAG = 4;\n\n /** Used to compose bitmasks for value comparisons. */\n var COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n /** Used to compose bitmasks for function metadata. */\n var WRAP_BIND_FLAG = 1,\n WRAP_BIND_KEY_FLAG = 2,\n WRAP_CURRY_BOUND_FLAG = 4,\n WRAP_CURRY_FLAG = 8,\n WRAP_CURRY_RIGHT_FLAG = 16,\n WRAP_PARTIAL_FLAG = 32,\n WRAP_PARTIAL_RIGHT_FLAG = 64,\n WRAP_ARY_FLAG = 128,\n WRAP_REARG_FLAG = 256,\n WRAP_FLIP_FLAG = 512;\n\n /** Used as default options for `_.truncate`. */\n var DEFAULT_TRUNC_LENGTH = 30,\n DEFAULT_TRUNC_OMISSION = '...';\n\n /** Used to detect hot functions by number of calls within a span of milliseconds. */\n var HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n /** Used to indicate the type of lazy iteratees. */\n var LAZY_FILTER_FLAG = 1,\n LAZY_MAP_FLAG = 2,\n LAZY_WHILE_FLAG = 3;\n\n /** Used as references for various `Number` constants. */\n var INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991,\n MAX_INTEGER = 1.7976931348623157e+308,\n NAN = 0 / 0;\n\n /** Used as references for the maximum length and index of an array. */\n var MAX_ARRAY_LENGTH = 4294967295,\n MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n /** Used to associate wrap methods with their bit flags. */\n var wrapFlags = [\n ['ary', WRAP_ARY_FLAG],\n ['bind', WRAP_BIND_FLAG],\n ['bindKey', WRAP_BIND_KEY_FLAG],\n ['curry', WRAP_CURRY_FLAG],\n ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n ['flip', WRAP_FLIP_FLAG],\n ['partial', WRAP_PARTIAL_FLAG],\n ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n ['rearg', WRAP_REARG_FLAG]\n ];\n\n /** `Object#toString` result references. */\n var argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n asyncTag = '[object AsyncFunction]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n domExcTag = '[object DOMException]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n nullTag = '[object Null]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n proxyTag = '[object Proxy]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n undefinedTag = '[object Undefined]',\n weakMapTag = '[object WeakMap]',\n weakSetTag = '[object WeakSet]';\n\n var arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n /** Used to match empty string literals in compiled template source. */\n var reEmptyStringLeading = /\\b__p \\+= '';/g,\n reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n /** Used to match HTML entities and HTML characters. */\n var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n reUnescapedHtml = /[&<>\"']/g,\n reHasEscapedHtml = RegExp(reEscapedHtml.source),\n reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n /** Used to match template delimiters. */\n var reEscape = /<%-([\\s\\S]+?)%>/g,\n reEvaluate = /<%([\\s\\S]+?)%>/g,\n reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n /** Used to match property names within property paths. */\n var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/,\n rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n /**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\n var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n reHasRegExpChar = RegExp(reRegExpChar.source);\n\n /** Used to match leading and trailing whitespace. */\n var reTrim = /^\\s+|\\s+$/g,\n reTrimStart = /^\\s+/,\n reTrimEnd = /\\s+$/;\n\n /** Used to match wrap detail comments. */\n var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n reSplitDetails = /,? & /;\n\n /** Used to match words composed of alphanumeric characters. */\n var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n /** Used to match backslashes in property paths. */\n var reEscapeChar = /\\\\(\\\\)?/g;\n\n /**\n * Used to match\n * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n */\n var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n /** Used to match `RegExp` flags from their coerced string values. */\n var reFlags = /\\w*$/;\n\n /** Used to detect bad signed hexadecimal string values. */\n var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n /** Used to detect binary string values. */\n var reIsBinary = /^0b[01]+$/i;\n\n /** Used to detect host constructors (Safari). */\n var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n /** Used to detect octal string values. */\n var reIsOctal = /^0o[0-7]+$/i;\n\n /** Used to detect unsigned integer values. */\n var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n /** Used to match Latin Unicode letters (excluding mathematical operators). */\n var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n /** Used to ensure capturing order of template delimiters. */\n var reNoMatch = /($^)/;\n\n /** Used to match unescaped characters in compiled string literals. */\n var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n /** Used to compose unicode character classes. */\n var rsAstralRange = '\\\\ud800-\\\\udfff',\n rsComboMarksRange = '\\\\u0300-\\\\u036f',\n reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n rsDingbatRange = '\\\\u2700-\\\\u27bf',\n rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n rsPunctuationRange = '\\\\u2000-\\\\u206f',\n 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',\n rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n rsVarRange = '\\\\ufe0e\\\\ufe0f',\n rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n /** Used to compose unicode capture groups. */\n var rsApos = \"['\\u2019]\",\n rsAstral = '[' + rsAstralRange + ']',\n rsBreak = '[' + rsBreakRange + ']',\n rsCombo = '[' + rsComboRange + ']',\n rsDigits = '\\\\d+',\n rsDingbat = '[' + rsDingbatRange + ']',\n rsLower = '[' + rsLowerRange + ']',\n rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n rsNonAstral = '[^' + rsAstralRange + ']',\n rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n rsUpper = '[' + rsUpperRange + ']',\n rsZWJ = '\\\\u200d';\n\n /** Used to compose unicode regexes. */\n var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n reOptMod = rsModifier + '?',\n rsOptVar = '[' + rsVarRange + ']?',\n rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n rsSeq = rsOptVar + reOptMod + rsOptJoin,\n rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n /** Used to match apostrophes. */\n var reApos = RegExp(rsApos, 'g');\n\n /**\n * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n */\n var reComboMark = RegExp(rsCombo, 'g');\n\n /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n /** Used to match complex or compound words. */\n var reUnicodeWord = RegExp([\n rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n rsUpper + '+' + rsOptContrUpper,\n rsOrdUpper,\n rsOrdLower,\n rsDigits,\n rsEmoji\n ].join('|'), 'g');\n\n /** 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/). */\n var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');\n\n /** Used to detect strings that need a more robust regexp to match words. */\n 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 ]/;\n\n /** Used to assign default `context` object properties. */\n var contextProps = [\n 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n ];\n\n /** Used to make template sourceURLs easier to identify. */\n var templateCounter = -1;\n\n /** Used to identify `toStringTag` values of typed arrays. */\n var typedArrayTags = {};\n typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n typedArrayTags[uint32Tag] = true;\n typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n typedArrayTags[setTag] = typedArrayTags[stringTag] =\n typedArrayTags[weakMapTag] = false;\n\n /** Used to identify `toStringTag` values supported by `_.clone`. */\n var cloneableTags = {};\n cloneableTags[argsTag] = cloneableTags[arrayTag] =\n cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n cloneableTags[boolTag] = cloneableTags[dateTag] =\n cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n cloneableTags[int32Tag] = cloneableTags[mapTag] =\n cloneableTags[numberTag] = cloneableTags[objectTag] =\n cloneableTags[regexpTag] = cloneableTags[setTag] =\n cloneableTags[stringTag] = cloneableTags[symbolTag] =\n cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n cloneableTags[errorTag] = cloneableTags[funcTag] =\n cloneableTags[weakMapTag] = false;\n\n /** Used to map Latin Unicode letters to basic Latin letters. */\n var deburredLetters = {\n // Latin-1 Supplement block.\n '\\xc0': 'A', '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n '\\xe0': 'a', '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n '\\xc7': 'C', '\\xe7': 'c',\n '\\xd0': 'D', '\\xf0': 'd',\n '\\xc8': 'E', '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n '\\xe8': 'e', '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n '\\xcc': 'I', '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n '\\xec': 'i', '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n '\\xd1': 'N', '\\xf1': 'n',\n '\\xd2': 'O', '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n '\\xf2': 'o', '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n '\\xd9': 'U', '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n '\\xf9': 'u', '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n '\\xdd': 'Y', '\\xfd': 'y', '\\xff': 'y',\n '\\xc6': 'Ae', '\\xe6': 'ae',\n '\\xde': 'Th', '\\xfe': 'th',\n '\\xdf': 'ss',\n // Latin Extended-A block.\n '\\u0100': 'A', '\\u0102': 'A', '\\u0104': 'A',\n '\\u0101': 'a', '\\u0103': 'a', '\\u0105': 'a',\n '\\u0106': 'C', '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n '\\u0107': 'c', '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n '\\u010e': 'D', '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n '\\u0112': 'E', '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n '\\u0113': 'e', '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n '\\u011c': 'G', '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n '\\u011d': 'g', '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n '\\u0124': 'H', '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n '\\u0128': 'I', '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n '\\u0129': 'i', '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n '\\u0134': 'J', '\\u0135': 'j',\n '\\u0136': 'K', '\\u0137': 'k', '\\u0138': 'k',\n '\\u0139': 'L', '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n '\\u013a': 'l', '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n '\\u0143': 'N', '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n '\\u0144': 'n', '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n '\\u014c': 'O', '\\u014e': 'O', '\\u0150': 'O',\n '\\u014d': 'o', '\\u014f': 'o', '\\u0151': 'o',\n '\\u0154': 'R', '\\u0156': 'R', '\\u0158': 'R',\n '\\u0155': 'r', '\\u0157': 'r', '\\u0159': 'r',\n '\\u015a': 'S', '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n '\\u015b': 's', '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n '\\u0162': 'T', '\\u0164': 'T', '\\u0166': 'T',\n '\\u0163': 't', '\\u0165': 't', '\\u0167': 't',\n '\\u0168': 'U', '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n '\\u0169': 'u', '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n '\\u0174': 'W', '\\u0175': 'w',\n '\\u0176': 'Y', '\\u0177': 'y', '\\u0178': 'Y',\n '\\u0179': 'Z', '\\u017b': 'Z', '\\u017d': 'Z',\n '\\u017a': 'z', '\\u017c': 'z', '\\u017e': 'z',\n '\\u0132': 'IJ', '\\u0133': 'ij',\n '\\u0152': 'Oe', '\\u0153': 'oe',\n '\\u0149': \"'n\", '\\u017f': 's'\n };\n\n /** Used to map characters to HTML entities. */\n var htmlEscapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": '''\n };\n\n /** Used to map HTML entities to characters. */\n var htmlUnescapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '"': '\"',\n ''': \"'\"\n };\n\n /** Used to escape characters for inclusion in compiled string literals. */\n var stringEscapes = {\n '\\\\': '\\\\',\n \"'\": \"'\",\n '\\n': 'n',\n '\\r': 'r',\n '\\u2028': 'u2028',\n '\\u2029': 'u2029'\n };\n\n /** Built-in method references without a dependency on `root`. */\n var freeParseFloat = parseFloat,\n freeParseInt = parseInt;\n\n /** Detect free variable `global` from Node.js. */\n var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n /** Detect free variable `self`. */\n var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n /** Used as a reference to the global object. */\n var root = freeGlobal || freeSelf || Function('return this')();\n\n /** Detect free variable `exports`. */\n var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n /** Detect free variable `module`. */\n var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n /** Detect the popular CommonJS extension `module.exports`. */\n var moduleExports = freeModule && freeModule.exports === freeExports;\n\n /** Detect free variable `process` from Node.js. */\n var freeProcess = moduleExports && freeGlobal.process;\n\n /** Used to access faster Node.js helpers. */\n var nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n }());\n\n /* Node.js helper references. */\n var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n nodeIsDate = nodeUtil && nodeUtil.isDate,\n nodeIsMap = nodeUtil && nodeUtil.isMap,\n nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n nodeIsSet = nodeUtil && nodeUtil.isSet,\n nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n /*--------------------------------------------------------------------------*/\n\n /**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\n function apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n }\n\n /**\n * A specialized version of `baseAggregator` for arrays.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\n function arrayAggregator(array, setter, iteratee, accumulator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n var value = array[index];\n setter(accumulator, value, iteratee(value), array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\n function arrayEach(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n }\n\n /**\n * A specialized version of `_.forEachRight` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\n function arrayEachRight(array, iteratee) {\n var length = array == null ? 0 : array.length;\n\n while (length--) {\n if (iteratee(array[length], length, array) === false) {\n break;\n }\n }\n return array;\n }\n\n /**\n * A specialized version of `_.every` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n */\n function arrayEvery(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (!predicate(array[index], index, array)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\n function arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n function arrayIncludes(array, value) {\n var length = array == null ? 0 : array.length;\n return !!length && baseIndexOf(array, value, 0) > -1;\n }\n\n /**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n function arrayIncludesWith(array, value, comparator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (comparator(value, array[index])) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n function arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n }\n\n /**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\n function arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n }\n\n /**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {*} Returns the accumulated value.\n */\n function arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.reduceRight` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the last element of `array` as\n * the initial value.\n * @returns {*} Returns the accumulated value.\n */\n function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n var length = array == null ? 0 : array.length;\n if (initAccum && length) {\n accumulator = array[--length];\n }\n while (length--) {\n accumulator = iteratee(accumulator, array[length], length, array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\n function arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * Gets the size of an ASCII `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\n var asciiSize = baseProperty('length');\n\n /**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function asciiToArray(string) {\n return string.split('');\n }\n\n /**\n * Splits an ASCII `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\n function asciiWords(string) {\n return string.match(reAsciiWord) || [];\n }\n\n /**\n * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n * without support for iteratee shorthands, which iterates over `collection`\n * using `eachFunc`.\n *\n * @private\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {Function} eachFunc The function to iterate over `collection`.\n * @returns {*} Returns the found element or its key, else `undefined`.\n */\n function baseFindKey(collection, predicate, eachFunc) {\n var result;\n eachFunc(collection, function(value, key, collection) {\n if (predicate(value, key, collection)) {\n result = key;\n return false;\n }\n });\n return result;\n }\n\n /**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseFindIndex(array, predicate, fromIndex, fromRight) {\n var length = array.length,\n index = fromIndex + (fromRight ? 1 : -1);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (predicate(array[index], index, array)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseIndexOf(array, value, fromIndex) {\n return value === value\n ? strictIndexOf(array, value, fromIndex)\n : baseFindIndex(array, baseIsNaN, fromIndex);\n }\n\n /**\n * This function is like `baseIndexOf` except that it accepts a comparator.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseIndexOfWith(array, value, fromIndex, comparator) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (comparator(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\n function baseIsNaN(value) {\n return value !== value;\n }\n\n /**\n * The base implementation of `_.mean` and `_.meanBy` without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {number} Returns the mean.\n */\n function baseMean(array, iteratee) {\n var length = array == null ? 0 : array.length;\n return length ? (baseSum(array, iteratee) / length) : NAN;\n }\n\n /**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\n function baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n }\n\n /**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\n function basePropertyOf(object) {\n return function(key) {\n return object == null ? undefined : object[key];\n };\n }\n\n /**\n * The base implementation of `_.reduce` and `_.reduceRight`, without support\n * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} accumulator The initial value.\n * @param {boolean} initAccum Specify using the first or last element of\n * `collection` as the initial value.\n * @param {Function} eachFunc The function to iterate over `collection`.\n * @returns {*} Returns the accumulated value.\n */\n function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n eachFunc(collection, function(value, index, collection) {\n accumulator = initAccum\n ? (initAccum = false, value)\n : iteratee(accumulator, value, index, collection);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.sortBy` which uses `comparer` to define the\n * sort order of `array` and replaces criteria objects with their corresponding\n * values.\n *\n * @private\n * @param {Array} array The array to sort.\n * @param {Function} comparer The function to define sort order.\n * @returns {Array} Returns `array`.\n */\n function baseSortBy(array, comparer) {\n var length = array.length;\n\n array.sort(comparer);\n while (length--) {\n array[length] = array[length].value;\n }\n return array;\n }\n\n /**\n * The base implementation of `_.sum` and `_.sumBy` without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {number} Returns the sum.\n */\n function baseSum(array, iteratee) {\n var result,\n index = -1,\n length = array.length;\n\n while (++index < length) {\n var current = iteratee(array[index]);\n if (current !== undefined) {\n result = result === undefined ? current : (result + current);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\n function baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n }\n\n /**\n * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n * of key-value pairs for `object` corresponding to the property names of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the key-value pairs.\n */\n function baseToPairs(object, props) {\n return arrayMap(props, function(key) {\n return [key, object[key]];\n });\n }\n\n /**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\n function baseUnary(func) {\n return function(value) {\n return func(value);\n };\n }\n\n /**\n * The base implementation of `_.values` and `_.valuesIn` which creates an\n * array of `object` property values corresponding to the property names\n * of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the array of property values.\n */\n function baseValues(object, props) {\n return arrayMap(props, function(key) {\n return object[key];\n });\n }\n\n /**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function cacheHas(cache, key) {\n return cache.has(key);\n }\n\n /**\n * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the first unmatched string symbol.\n */\n function charsStartIndex(strSymbols, chrSymbols) {\n var index = -1,\n length = strSymbols.length;\n\n while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n return index;\n }\n\n /**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the last unmatched string symbol.\n */\n function charsEndIndex(strSymbols, chrSymbols) {\n var index = strSymbols.length;\n\n while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n return index;\n }\n\n /**\n * Gets the number of `placeholder` occurrences in `array`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} placeholder The placeholder to search for.\n * @returns {number} Returns the placeholder count.\n */\n function countHolders(array, placeholder) {\n var length = array.length,\n result = 0;\n\n while (length--) {\n if (array[length] === placeholder) {\n ++result;\n }\n }\n return result;\n }\n\n /**\n * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n * letters to basic Latin letters.\n *\n * @private\n * @param {string} letter The matched letter to deburr.\n * @returns {string} Returns the deburred letter.\n */\n var deburrLetter = basePropertyOf(deburredLetters);\n\n /**\n * Used by `_.escape` to convert characters to HTML entities.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n /**\n * Used by `_.template` to escape characters for inclusion in compiled string literals.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n function escapeStringChar(chr) {\n return '\\\\' + stringEscapes[chr];\n }\n\n /**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n function getValue(object, key) {\n return object == null ? undefined : object[key];\n }\n\n /**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\n function hasUnicode(string) {\n return reHasUnicode.test(string);\n }\n\n /**\n * Checks if `string` contains a word composed of Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a word is found, else `false`.\n */\n function hasUnicodeWord(string) {\n return reHasUnicodeWord.test(string);\n }\n\n /**\n * Converts `iterator` to an array.\n *\n * @private\n * @param {Object} iterator The iterator to convert.\n * @returns {Array} Returns the converted array.\n */\n function iteratorToArray(iterator) {\n var data,\n result = [];\n\n while (!(data = iterator.next()).done) {\n result.push(data.value);\n }\n return result;\n }\n\n /**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\n function mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n }\n\n /**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\n function overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n }\n\n /**\n * Replaces all `placeholder` elements in `array` with an internal placeholder\n * and returns an array of their indexes.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {*} placeholder The placeholder to replace.\n * @returns {Array} Returns the new array of placeholder indexes.\n */\n function replaceHolders(array, placeholder) {\n var index = -1,\n length = array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (value === placeholder || value === PLACEHOLDER) {\n array[index] = PLACEHOLDER;\n result[resIndex++] = index;\n }\n }\n return result;\n }\n\n /**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\n function setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n }\n\n /**\n * Converts `set` to its value-value pairs.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the value-value pairs.\n */\n function setToPairs(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = [value, value];\n });\n return result;\n }\n\n /**\n * A specialized version of `_.indexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function strictIndexOf(array, value, fromIndex) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (array[index] === value) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * A specialized version of `_.lastIndexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function strictLastIndexOf(array, value, fromIndex) {\n var index = fromIndex + 1;\n while (index--) {\n if (array[index] === value) {\n return index;\n }\n }\n return index;\n }\n\n /**\n * Gets the number of symbols in `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the string size.\n */\n function stringSize(string) {\n return hasUnicode(string)\n ? unicodeSize(string)\n : asciiSize(string);\n }\n\n /**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function stringToArray(string) {\n return hasUnicode(string)\n ? unicodeToArray(string)\n : asciiToArray(string);\n }\n\n /**\n * Used by `_.unescape` to convert HTML entities to characters.\n *\n * @private\n * @param {string} chr The matched character to unescape.\n * @returns {string} Returns the unescaped character.\n */\n var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n /**\n * Gets the size of a Unicode `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\n function unicodeSize(string) {\n var result = reUnicode.lastIndex = 0;\n while (reUnicode.test(string)) {\n ++result;\n }\n return result;\n }\n\n /**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function unicodeToArray(string) {\n return string.match(reUnicode) || [];\n }\n\n /**\n * Splits a Unicode `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\n function unicodeWords(string) {\n return string.match(reUnicodeWord) || [];\n }\n\n /*--------------------------------------------------------------------------*/\n\n /**\n * Create a new pristine `lodash` function using the `context` object.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Util\n * @param {Object} [context=root] The context object.\n * @returns {Function} Returns a new `lodash` function.\n * @example\n *\n * _.mixin({ 'foo': _.constant('foo') });\n *\n * var lodash = _.runInContext();\n * lodash.mixin({ 'bar': lodash.constant('bar') });\n *\n * _.isFunction(_.foo);\n * // => true\n * _.isFunction(_.bar);\n * // => false\n *\n * lodash.isFunction(lodash.foo);\n * // => false\n * lodash.isFunction(lodash.bar);\n * // => true\n *\n * // Create a suped-up `defer` in Node.js.\n * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n */\n var runInContext = (function runInContext(context) {\n context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n /** Built-in constructor references. */\n var Array = context.Array,\n Date = context.Date,\n Error = context.Error,\n Function = context.Function,\n Math = context.Math,\n Object = context.Object,\n RegExp = context.RegExp,\n String = context.String,\n TypeError = context.TypeError;\n\n /** Used for built-in method references. */\n var arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n /** Used to detect overreaching core-js shims. */\n var coreJsData = context['__core-js_shared__'];\n\n /** Used to resolve the decompiled source of functions. */\n var funcToString = funcProto.toString;\n\n /** Used to check objects for own properties. */\n var hasOwnProperty = objectProto.hasOwnProperty;\n\n /** Used to generate unique IDs. */\n var idCounter = 0;\n\n /** Used to detect methods masquerading as native. */\n var maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n }());\n\n /**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\n var nativeObjectToString = objectProto.toString;\n\n /** Used to infer the `Object` constructor. */\n var objectCtorString = funcToString.call(Object);\n\n /** Used to restore the original `_` reference in `_.noConflict`. */\n var oldDash = root._;\n\n /** Used to detect if a method is native. */\n var reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n );\n\n /** Built-in value references. */\n var Buffer = moduleExports ? context.Buffer : undefined,\n Symbol = context.Symbol,\n Uint8Array = context.Uint8Array,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice,\n spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n symIterator = Symbol ? Symbol.iterator : undefined,\n symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n var defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n }());\n\n /** Mocked built-ins. */\n var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n ctxNow = Date && Date.now !== root.Date.now && Date.now,\n ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n /* Built-in method references for those with the same name as other `lodash` methods. */\n var nativeCeil = Math.ceil,\n nativeFloor = Math.floor,\n nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeIsFinite = context.isFinite,\n nativeJoin = arrayProto.join,\n nativeKeys = overArg(Object.keys, Object),\n nativeMax = Math.max,\n nativeMin = Math.min,\n nativeNow = Date.now,\n nativeParseInt = context.parseInt,\n nativeRandom = Math.random,\n nativeReverse = arrayProto.reverse;\n\n /* Built-in method references that are verified to be native. */\n var DataView = getNative(context, 'DataView'),\n Map = getNative(context, 'Map'),\n Promise = getNative(context, 'Promise'),\n Set = getNative(context, 'Set'),\n WeakMap = getNative(context, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n /** Used to store function metadata. */\n var metaMap = WeakMap && new WeakMap;\n\n /** Used to lookup unminified function names. */\n var realNames = {};\n\n /** Used to detect maps, sets, and weakmaps. */\n var dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n /** Used to convert symbols to primitives and strings. */\n var symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a `lodash` object which wraps `value` to enable implicit method\n * chain sequences. Methods that operate on and return arrays, collections,\n * and functions can be chained together. Methods that retrieve a single value\n * or may return a primitive value will automatically end the chain sequence\n * and return the unwrapped value. Otherwise, the value must be unwrapped\n * with `_#value`.\n *\n * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n * enabled using `_.chain`.\n *\n * The execution of chained methods is lazy, that is, it's deferred until\n * `_#value` is implicitly or explicitly called.\n *\n * Lazy evaluation allows several methods to support shortcut fusion.\n * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n * the creation of intermediate arrays and can greatly reduce the number of\n * iteratee executions. Sections of a chain sequence qualify for shortcut\n * fusion if the section is applied to an array and iteratees accept only\n * one argument. The heuristic for whether a section qualifies for shortcut\n * fusion is subject to change.\n *\n * Chaining is supported in custom builds as long as the `_#value` method is\n * directly or indirectly included in the build.\n *\n * In addition to lodash methods, wrappers have `Array` and `String` methods.\n *\n * The wrapper `Array` methods are:\n * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n *\n * The wrapper `String` methods are:\n * `replace` and `split`\n *\n * The wrapper methods that support shortcut fusion are:\n * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n *\n * The chainable wrapper methods are:\n * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n * `zipObject`, `zipObjectDeep`, and `zipWith`\n *\n * The wrapper methods that are **not** chainable by default are:\n * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n * `upperFirst`, `value`, and `words`\n *\n * @name _\n * @constructor\n * @category Seq\n * @param {*} value The value to wrap in a `lodash` instance.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var wrapped = _([1, 2, 3]);\n *\n * // Returns an unwrapped value.\n * wrapped.reduce(_.add);\n * // => 6\n *\n * // Returns a wrapped value.\n * var squares = wrapped.map(square);\n *\n * _.isArray(squares);\n * // => false\n *\n * _.isArray(squares.value());\n * // => true\n */\n function lodash(value) {\n if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n if (value instanceof LodashWrapper) {\n return value;\n }\n if (hasOwnProperty.call(value, '__wrapped__')) {\n return wrapperClone(value);\n }\n }\n return new LodashWrapper(value);\n }\n\n /**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\n var baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n }());\n\n /**\n * The function whose prototype chain sequence wrappers inherit from.\n *\n * @private\n */\n function baseLodash() {\n // No operation performed.\n }\n\n /**\n * The base constructor for creating `lodash` wrapper objects.\n *\n * @private\n * @param {*} value The value to wrap.\n * @param {boolean} [chainAll] Enable explicit method chain sequences.\n */\n function LodashWrapper(value, chainAll) {\n this.__wrapped__ = value;\n this.__actions__ = [];\n this.__chain__ = !!chainAll;\n this.__index__ = 0;\n this.__values__ = undefined;\n }\n\n /**\n * By default, the template delimiters used by lodash are like those in\n * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n * following template settings to use alternative delimiters.\n *\n * @static\n * @memberOf _\n * @type {Object}\n */\n lodash.templateSettings = {\n\n /**\n * Used to detect `data` property values to be HTML-escaped.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'escape': reEscape,\n\n /**\n * Used to detect code to be evaluated.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'evaluate': reEvaluate,\n\n /**\n * Used to detect `data` property values to inject.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'interpolate': reInterpolate,\n\n /**\n * Used to reference the data object in the template text.\n *\n * @memberOf _.templateSettings\n * @type {string}\n */\n 'variable': '',\n\n /**\n * Used to import variables into the compiled template.\n *\n * @memberOf _.templateSettings\n * @type {Object}\n */\n 'imports': {\n\n /**\n * A reference to the `lodash` function.\n *\n * @memberOf _.templateSettings.imports\n * @type {Function}\n */\n '_': lodash\n }\n };\n\n // Ensure wrappers are instances of `baseLodash`.\n lodash.prototype = baseLodash.prototype;\n lodash.prototype.constructor = lodash;\n\n LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n LodashWrapper.prototype.constructor = LodashWrapper;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n *\n * @private\n * @constructor\n * @param {*} value The value to wrap.\n */\n function LazyWrapper(value) {\n this.__wrapped__ = value;\n this.__actions__ = [];\n this.__dir__ = 1;\n this.__filtered__ = false;\n this.__iteratees__ = [];\n this.__takeCount__ = MAX_ARRAY_LENGTH;\n this.__views__ = [];\n }\n\n /**\n * Creates a clone of the lazy wrapper object.\n *\n * @private\n * @name clone\n * @memberOf LazyWrapper\n * @returns {Object} Returns the cloned `LazyWrapper` object.\n */\n function lazyClone() {\n var result = new LazyWrapper(this.__wrapped__);\n result.__actions__ = copyArray(this.__actions__);\n result.__dir__ = this.__dir__;\n result.__filtered__ = this.__filtered__;\n result.__iteratees__ = copyArray(this.__iteratees__);\n result.__takeCount__ = this.__takeCount__;\n result.__views__ = copyArray(this.__views__);\n return result;\n }\n\n /**\n * Reverses the direction of lazy iteration.\n *\n * @private\n * @name reverse\n * @memberOf LazyWrapper\n * @returns {Object} Returns the new reversed `LazyWrapper` object.\n */\n function lazyReverse() {\n if (this.__filtered__) {\n var result = new LazyWrapper(this);\n result.__dir__ = -1;\n result.__filtered__ = true;\n } else {\n result = this.clone();\n result.__dir__ *= -1;\n }\n return result;\n }\n\n /**\n * Extracts the unwrapped value from its lazy wrapper.\n *\n * @private\n * @name value\n * @memberOf LazyWrapper\n * @returns {*} Returns the unwrapped value.\n */\n function lazyValue() {\n var array = this.__wrapped__.value(),\n dir = this.__dir__,\n isArr = isArray(array),\n isRight = dir < 0,\n arrLength = isArr ? array.length : 0,\n view = getView(0, arrLength, this.__views__),\n start = view.start,\n end = view.end,\n length = end - start,\n index = isRight ? end : (start - 1),\n iteratees = this.__iteratees__,\n iterLength = iteratees.length,\n resIndex = 0,\n takeCount = nativeMin(length, this.__takeCount__);\n\n if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n return baseWrapperValue(array, this.__actions__);\n }\n var result = [];\n\n outer:\n while (length-- && resIndex < takeCount) {\n index += dir;\n\n var iterIndex = -1,\n value = array[index];\n\n while (++iterIndex < iterLength) {\n var data = iteratees[iterIndex],\n iteratee = data.iteratee,\n type = data.type,\n computed = iteratee(value);\n\n if (type == LAZY_MAP_FLAG) {\n value = computed;\n } else if (!computed) {\n if (type == LAZY_FILTER_FLAG) {\n continue outer;\n } else {\n break outer;\n }\n }\n }\n result[resIndex++] = value;\n }\n return result;\n }\n\n // Ensure `LazyWrapper` is an instance of `baseLodash`.\n LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n LazyWrapper.prototype.constructor = LazyWrapper;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\n function hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n }\n\n /**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n }\n\n /**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n }\n\n /**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\n function hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n }\n\n // Add methods to `Hash`.\n Hash.prototype.clear = hashClear;\n Hash.prototype['delete'] = hashDelete;\n Hash.prototype.get = hashGet;\n Hash.prototype.has = hashHas;\n Hash.prototype.set = hashSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\n function listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n }\n\n /**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n }\n\n /**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n }\n\n /**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\n function listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n }\n\n // Add methods to `ListCache`.\n ListCache.prototype.clear = listCacheClear;\n ListCache.prototype['delete'] = listCacheDelete;\n ListCache.prototype.get = listCacheGet;\n ListCache.prototype.has = listCacheHas;\n ListCache.prototype.set = listCacheSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\n function mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n }\n\n /**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n }\n\n /**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function mapCacheGet(key) {\n return getMapData(this, key).get(key);\n }\n\n /**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function mapCacheHas(key) {\n return getMapData(this, key).has(key);\n }\n\n /**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\n function mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n }\n\n // Add methods to `MapCache`.\n MapCache.prototype.clear = mapCacheClear;\n MapCache.prototype['delete'] = mapCacheDelete;\n MapCache.prototype.get = mapCacheGet;\n MapCache.prototype.has = mapCacheHas;\n MapCache.prototype.set = mapCacheSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\n function SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n }\n\n /**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\n function setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n }\n\n /**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\n function setCacheHas(value) {\n return this.__data__.has(value);\n }\n\n // Add methods to `SetCache`.\n SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n SetCache.prototype.has = setCacheHas;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n }\n\n /**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\n function stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n }\n\n /**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function stackGet(key) {\n return this.__data__.get(key);\n }\n\n /**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function stackHas(key) {\n return this.__data__.has(key);\n }\n\n /**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\n function stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n }\n\n // Add methods to `Stack`.\n Stack.prototype.clear = stackClear;\n Stack.prototype['delete'] = stackDelete;\n Stack.prototype.get = stackGet;\n Stack.prototype.has = stackHas;\n Stack.prototype.set = stackSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\n function arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `_.sample` for arrays.\n *\n * @private\n * @param {Array} array The array to sample.\n * @returns {*} Returns the random element.\n */\n function arraySample(array) {\n var length = array.length;\n return length ? array[baseRandom(0, length - 1)] : undefined;\n }\n\n /**\n * A specialized version of `_.sampleSize` for arrays.\n *\n * @private\n * @param {Array} array The array to sample.\n * @param {number} n The number of elements to sample.\n * @returns {Array} Returns the random elements.\n */\n function arraySampleSize(array, n) {\n return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n }\n\n /**\n * A specialized version of `_.shuffle` for arrays.\n *\n * @private\n * @param {Array} array The array to shuffle.\n * @returns {Array} Returns the new shuffled array.\n */\n function arrayShuffle(array) {\n return shuffleSelf(copyArray(array));\n }\n\n /**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n }\n\n /**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n }\n\n /**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n }\n\n /**\n * Aggregates elements of `collection` on `accumulator` with keys transformed\n * by `iteratee` and values set by `setter`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\n function baseAggregator(collection, setter, iteratee, accumulator) {\n baseEach(collection, function(value, key, collection) {\n setter(accumulator, value, iteratee(value), collection);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\n function baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n }\n\n /**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\n function baseAssignIn(object, source) {\n return object && copyObject(source, keysIn(source), object);\n }\n\n /**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n }\n\n /**\n * The base implementation of `_.at` without support for individual paths.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {string[]} paths The property paths to pick.\n * @returns {Array} Returns the picked elements.\n */\n function baseAt(object, paths) {\n var index = -1,\n length = paths.length,\n result = Array(length),\n skip = object == null;\n\n while (++index < length) {\n result[index] = skip ? undefined : get(object, paths[index]);\n }\n return result;\n }\n\n /**\n * The base implementation of `_.clamp` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n */\n function baseClamp(number, lower, upper) {\n if (number === number) {\n if (upper !== undefined) {\n number = number <= upper ? number : upper;\n }\n if (lower !== undefined) {\n number = number >= lower ? number : lower;\n }\n }\n return number;\n }\n\n /**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Deep clone\n * 2 - Flatten inherited properties\n * 4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\n function baseClone(value, bitmask, customizer, key, object, stack) {\n var result,\n isDeep = bitmask & CLONE_DEEP_FLAG,\n isFlat = bitmask & CLONE_FLAT_FLAG,\n isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag || tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n result = (isFlat || isFunc) ? {} : initCloneObject(value);\n if (!isDeep) {\n return isFlat\n ? copySymbolsIn(value, baseAssignIn(result, value))\n : copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack || (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (isSet(value)) {\n value.forEach(function(subValue) {\n result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n });\n } else if (isMap(value)) {\n value.forEach(function(subValue, key) {\n result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n }\n\n var keysFunc = isFull\n ? (isFlat ? getAllKeysIn : getAllKeys)\n : (isFlat ? keysIn : keys);\n\n var props = isArr ? undefined : keysFunc(value);\n arrayEach(props || value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n return result;\n }\n\n /**\n * The base implementation of `_.conforms` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property predicates to conform to.\n * @returns {Function} Returns the new spec function.\n */\n function baseConforms(source) {\n var props = keys(source);\n return function(object) {\n return baseConformsTo(object, source, props);\n };\n }\n\n /**\n * The base implementation of `_.conformsTo` which accepts `props` to check.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property predicates to conform to.\n * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n */\n function baseConformsTo(object, source, props) {\n var length = props.length;\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (length--) {\n var key = props[length],\n predicate = source[key],\n value = object[key];\n\n if ((value === undefined && !(key in object)) || !predicate(value)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * The base implementation of `_.delay` and `_.defer` which accepts `args`\n * to provide to `func`.\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {Array} args The arguments to provide to `func`.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\n function baseDelay(func, wait, args) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return setTimeout(function() { func.apply(undefined, args); }, wait);\n }\n\n /**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\n function baseDifference(array, values, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n isCommon = true,\n length = array.length,\n result = [],\n valuesLength = values.length;\n\n if (!length) {\n return result;\n }\n if (iteratee) {\n values = arrayMap(values, baseUnary(iteratee));\n }\n if (comparator) {\n includes = arrayIncludesWith;\n isCommon = false;\n }\n else if (values.length >= LARGE_ARRAY_SIZE) {\n includes = cacheHas;\n isCommon = false;\n values = new SetCache(values);\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee == null ? value : iteratee(value);\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var valuesIndex = valuesLength;\n while (valuesIndex--) {\n if (values[valuesIndex] === computed) {\n continue outer;\n }\n }\n result.push(value);\n }\n else if (!includes(values, computed, comparator)) {\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.forEach` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\n var baseEach = createBaseEach(baseForOwn);\n\n /**\n * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\n var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n /**\n * The base implementation of `_.every` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`\n */\n function baseEvery(collection, predicate) {\n var result = true;\n baseEach(collection, function(value, index, collection) {\n result = !!predicate(value, index, collection);\n return result;\n });\n return result;\n }\n\n /**\n * The base implementation of methods like `_.max` and `_.min` which accepts a\n * `comparator` to determine the extremum value.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The iteratee invoked per iteration.\n * @param {Function} comparator The comparator used to compare values.\n * @returns {*} Returns the extremum value.\n */\n function baseExtremum(array, iteratee, comparator) {\n var index = -1,\n length = array.length;\n\n while (++index < length) {\n var value = array[index],\n current = iteratee(value);\n\n if (current != null && (computed === undefined\n ? (current === current && !isSymbol(current))\n : comparator(current, computed)\n )) {\n var computed = current,\n result = value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.fill` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n */\n function baseFill(array, value, start, end) {\n var length = array.length;\n\n start = toInteger(start);\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = (end === undefined || end > length) ? length : toInteger(end);\n if (end < 0) {\n end += length;\n }\n end = start > end ? 0 : toLength(end);\n while (start < end) {\n array[start++] = value;\n }\n return array;\n }\n\n /**\n * The base implementation of `_.filter` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\n function baseFilter(collection, predicate) {\n var result = [];\n baseEach(collection, function(value, index, collection) {\n if (predicate(value, index, collection)) {\n result.push(value);\n }\n });\n return result;\n }\n\n /**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\n function baseFlatten(array, depth, predicate, isStrict, result) {\n var index = -1,\n length = array.length;\n\n predicate || (predicate = isFlattenable);\n result || (result = []);\n\n while (++index < length) {\n var value = array[index];\n if (depth > 0 && predicate(value)) {\n if (depth > 1) {\n // Recursively flatten arrays (susceptible to call stack limits).\n baseFlatten(value, depth - 1, predicate, isStrict, result);\n } else {\n arrayPush(result, value);\n }\n } else if (!isStrict) {\n result[result.length] = value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\n var baseFor = createBaseFor();\n\n /**\n * This function is like `baseFor` except that it iterates over properties\n * in the opposite order.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\n var baseForRight = createBaseFor(true);\n\n /**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\n function baseForOwn(object, iteratee) {\n return object && baseFor(object, iteratee, keys);\n }\n\n /**\n * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\n function baseForOwnRight(object, iteratee) {\n return object && baseForRight(object, iteratee, keys);\n }\n\n /**\n * The base implementation of `_.functions` which creates an array of\n * `object` function property names filtered from `props`.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Array} props The property names to filter.\n * @returns {Array} Returns the function names.\n */\n function baseFunctions(object, props) {\n return arrayFilter(props, function(key) {\n return isFunction(object[key]);\n });\n }\n\n /**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\n function baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n }\n\n /**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n }\n\n /**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\n function baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n }\n\n /**\n * The base implementation of `_.gt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than `other`,\n * else `false`.\n */\n function baseGt(value, other) {\n return value > other;\n }\n\n /**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\n function baseHas(object, key) {\n return object != null && hasOwnProperty.call(object, key);\n }\n\n /**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\n function baseHasIn(object, key) {\n return object != null && key in Object(object);\n }\n\n /**\n * The base implementation of `_.inRange` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to check.\n * @param {number} start The start of the range.\n * @param {number} end The end of the range.\n * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n */\n function baseInRange(number, start, end) {\n return number >= nativeMin(start, end) && number < nativeMax(start, end);\n }\n\n /**\n * The base implementation of methods like `_.intersection`, without support\n * for iteratee shorthands, that accepts an array of arrays to inspect.\n *\n * @private\n * @param {Array} arrays The arrays to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of shared values.\n */\n function baseIntersection(arrays, iteratee, comparator) {\n var includes = comparator ? arrayIncludesWith : arrayIncludes,\n length = arrays[0].length,\n othLength = arrays.length,\n othIndex = othLength,\n caches = Array(othLength),\n maxLength = Infinity,\n result = [];\n\n while (othIndex--) {\n var array = arrays[othIndex];\n if (othIndex && iteratee) {\n array = arrayMap(array, baseUnary(iteratee));\n }\n maxLength = nativeMin(array.length, maxLength);\n caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n ? new SetCache(othIndex && array)\n : undefined;\n }\n array = arrays[0];\n\n var index = -1,\n seen = caches[0];\n\n outer:\n while (++index < length && result.length < maxLength) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n value = (comparator || value !== 0) ? value : 0;\n if (!(seen\n ? cacheHas(seen, computed)\n : includes(result, computed, comparator)\n )) {\n othIndex = othLength;\n while (--othIndex) {\n var cache = caches[othIndex];\n if (!(cache\n ? cacheHas(cache, computed)\n : includes(arrays[othIndex], computed, comparator))\n ) {\n continue outer;\n }\n }\n if (seen) {\n seen.push(computed);\n }\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.invert` and `_.invertBy` which inverts\n * `object` with values transformed by `iteratee` and set by `setter`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform values.\n * @param {Object} accumulator The initial inverted object.\n * @returns {Function} Returns `accumulator`.\n */\n function baseInverter(object, setter, iteratee, accumulator) {\n baseForOwn(object, function(value, key, object) {\n setter(accumulator, iteratee(value), key, object);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.invoke` without support for individual\n * method arguments.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the method to invoke.\n * @param {Array} args The arguments to invoke the method with.\n * @returns {*} Returns the result of the invoked method.\n */\n function baseInvoke(object, path, args) {\n path = castPath(path, object);\n object = parent(object, path);\n var func = object == null ? object : object[toKey(last(path))];\n return func == null ? undefined : apply(func, object, args);\n }\n\n /**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\n function baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n }\n\n /**\n * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n */\n function baseIsArrayBuffer(value) {\n return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n }\n\n /**\n * The base implementation of `_.isDate` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n */\n function baseIsDate(value) {\n return isObjectLike(value) && baseGetTag(value) == dateTag;\n }\n\n /**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\n function baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n }\n\n /**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n }\n\n /**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\n function baseIsMap(value) {\n return isObjectLike(value) && getTag(value) == mapTag;\n }\n\n /**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\n function baseIsMatch(object, source, matchData, customizer) {\n var index = matchData.length,\n length = index,\n noCustomizer = !customizer;\n\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (index--) {\n var data = matchData[index];\n if ((noCustomizer && data[2])\n ? data[1] !== object[data[0]]\n : !(data[0] in object)\n ) {\n return false;\n }\n }\n while (++index < length) {\n data = matchData[index];\n var key = data[0],\n objValue = object[key],\n srcValue = data[1];\n\n if (noCustomizer && data[2]) {\n if (objValue === undefined && !(key in object)) {\n return false;\n }\n } else {\n var stack = new Stack;\n if (customizer) {\n var result = customizer(objValue, srcValue, key, object, source, stack);\n }\n if (!(result === undefined\n ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n : result\n )) {\n return false;\n }\n }\n }\n return true;\n }\n\n /**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\n function baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n }\n\n /**\n * The base implementation of `_.isRegExp` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n */\n function baseIsRegExp(value) {\n return isObjectLike(value) && baseGetTag(value) == regexpTag;\n }\n\n /**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\n function baseIsSet(value) {\n return isObjectLike(value) && getTag(value) == setTag;\n }\n\n /**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\n function baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n }\n\n /**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\n function baseIteratee(value) {\n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n if (typeof value == 'function') {\n return value;\n }\n if (value == null) {\n return identity;\n }\n if (typeof value == 'object') {\n return isArray(value)\n ? baseMatchesProperty(value[0], value[1])\n : baseMatches(value);\n }\n return property(value);\n }\n\n /**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.lt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n * else `false`.\n */\n function baseLt(value, other) {\n return value < other;\n }\n\n /**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n function baseMap(collection, iteratee) {\n var index = -1,\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value, key, collection) {\n result[++index] = iteratee(value, key, collection);\n });\n return result;\n }\n\n /**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatches(source) {\n var matchData = getMatchData(source);\n if (matchData.length == 1 && matchData[0][2]) {\n return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n }\n return function(object) {\n return object === source || baseIsMatch(object, source, matchData);\n };\n }\n\n /**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatchesProperty(path, srcValue) {\n if (isKey(path) && isStrictComparable(srcValue)) {\n return matchesStrictComparable(toKey(path), srcValue);\n }\n return function(object) {\n var objValue = get(object, path);\n return (objValue === undefined && objValue === srcValue)\n ? hasIn(object, path)\n : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n };\n }\n\n /**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\n function baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n }\n\n /**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\n function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n }\n\n /**\n * The base implementation of `_.nth` which doesn't coerce arguments.\n *\n * @private\n * @param {Array} array The array to query.\n * @param {number} n The index of the element to return.\n * @returns {*} Returns the nth element of `array`.\n */\n function baseNth(array, n) {\n var length = array.length;\n if (!length) {\n return;\n }\n n += n < 0 ? length : 0;\n return isIndex(n, length) ? array[n] : undefined;\n }\n\n /**\n * The base implementation of `_.orderBy` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n * @param {string[]} orders The sort orders of `iteratees`.\n * @returns {Array} Returns the new sorted array.\n */\n function baseOrderBy(collection, iteratees, orders) {\n if (iteratees.length) {\n iteratees = arrayMap(iteratees, function(iteratee) {\n if (isArray(iteratee)) {\n return function(value) {\n return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n }\n }\n return iteratee;\n });\n } else {\n iteratees = [identity];\n }\n\n var index = -1;\n iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n\n var result = baseMap(collection, function(value, key, collection) {\n var criteria = arrayMap(iteratees, function(iteratee) {\n return iteratee(value);\n });\n return { 'criteria': criteria, 'index': ++index, 'value': value };\n });\n\n return baseSortBy(result, function(object, other) {\n return compareMultiple(object, other, orders);\n });\n }\n\n /**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\n function basePick(object, paths) {\n return basePickBy(object, paths, function(value, path) {\n return hasIn(object, path);\n });\n }\n\n /**\n * The base implementation of `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\n function basePickBy(object, paths, predicate) {\n var index = -1,\n length = paths.length,\n result = {};\n\n while (++index < length) {\n var path = paths[index],\n value = baseGet(object, path);\n\n if (predicate(value, path)) {\n baseSet(result, castPath(path, object), value);\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\n function basePropertyDeep(path) {\n return function(object) {\n return baseGet(object, path);\n };\n }\n\n /**\n * The base implementation of `_.pullAllBy` without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns `array`.\n */\n function basePullAll(array, values, iteratee, comparator) {\n var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n index = -1,\n length = values.length,\n seen = array;\n\n if (array === values) {\n values = copyArray(values);\n }\n if (iteratee) {\n seen = arrayMap(array, baseUnary(iteratee));\n }\n while (++index < length) {\n var fromIndex = 0,\n value = values[index],\n computed = iteratee ? iteratee(value) : value;\n\n while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n if (seen !== array) {\n splice.call(seen, fromIndex, 1);\n }\n splice.call(array, fromIndex, 1);\n }\n }\n return array;\n }\n\n /**\n * The base implementation of `_.pullAt` without support for individual\n * indexes or capturing the removed elements.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {number[]} indexes The indexes of elements to remove.\n * @returns {Array} Returns `array`.\n */\n function basePullAt(array, indexes) {\n var length = array ? indexes.length : 0,\n lastIndex = length - 1;\n\n while (length--) {\n var index = indexes[length];\n if (length == lastIndex || index !== previous) {\n var previous = index;\n if (isIndex(index)) {\n splice.call(array, index, 1);\n } else {\n baseUnset(array, index);\n }\n }\n }\n return array;\n }\n\n /**\n * The base implementation of `_.random` without support for returning\n * floating-point numbers.\n *\n * @private\n * @param {number} lower The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the random number.\n */\n function baseRandom(lower, upper) {\n return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n }\n\n /**\n * The base implementation of `_.range` and `_.rangeRight` which doesn't\n * coerce arguments.\n *\n * @private\n * @param {number} start The start of the range.\n * @param {number} end The end of the range.\n * @param {number} step The value to increment or decrement by.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Array} Returns the range of numbers.\n */\n function baseRange(start, end, step, fromRight) {\n var index = -1,\n length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n result = Array(length);\n\n while (length--) {\n result[fromRight ? length : ++index] = start;\n start += step;\n }\n return result;\n }\n\n /**\n * The base implementation of `_.repeat` which doesn't coerce arguments.\n *\n * @private\n * @param {string} string The string to repeat.\n * @param {number} n The number of times to repeat the string.\n * @returns {string} Returns the repeated string.\n */\n function baseRepeat(string, n) {\n var result = '';\n if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n return result;\n }\n // Leverage the exponentiation by squaring algorithm for a faster repeat.\n // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n do {\n if (n % 2) {\n result += string;\n }\n n = nativeFloor(n / 2);\n if (n) {\n string += string;\n }\n } while (n);\n\n return result;\n }\n\n /**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\n function baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n }\n\n /**\n * The base implementation of `_.sample`.\n *\n * @private\n * @param {Array|Object} collection The collection to sample.\n * @returns {*} Returns the random element.\n */\n function baseSample(collection) {\n return arraySample(values(collection));\n }\n\n /**\n * The base implementation of `_.sampleSize` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to sample.\n * @param {number} n The number of elements to sample.\n * @returns {Array} Returns the random elements.\n */\n function baseSampleSize(collection, n) {\n var array = values(collection);\n return shuffleSelf(array, baseClamp(n, 0, array.length));\n }\n\n /**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\n function baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n }\n\n /**\n * The base implementation of `setData` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var baseSetData = !metaMap ? identity : function(func, data) {\n metaMap.set(func, data);\n return func;\n };\n\n /**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n var baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n };\n\n /**\n * The base implementation of `_.shuffle`.\n *\n * @private\n * @param {Array|Object} collection The collection to shuffle.\n * @returns {Array} Returns the new shuffled array.\n */\n function baseShuffle(collection) {\n return shuffleSelf(values(collection));\n }\n\n /**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\n function baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n }\n\n /**\n * The base implementation of `_.some` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\n function baseSome(collection, predicate) {\n var result;\n\n baseEach(collection, function(value, index, collection) {\n result = predicate(value, index, collection);\n return !result;\n });\n return !!result;\n }\n\n /**\n * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n * performs a binary search of `array` to determine the index at which `value`\n * should be inserted into `array` in order to maintain its sort order.\n *\n * @private\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {boolean} [retHighest] Specify returning the highest qualified index.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n */\n function baseSortedIndex(array, value, retHighest) {\n var low = 0,\n high = array == null ? low : array.length;\n\n if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n while (low < high) {\n var mid = (low + high) >>> 1,\n computed = array[mid];\n\n if (computed !== null && !isSymbol(computed) &&\n (retHighest ? (computed <= value) : (computed < value))) {\n low = mid + 1;\n } else {\n high = mid;\n }\n }\n return high;\n }\n return baseSortedIndexBy(array, value, identity, retHighest);\n }\n\n /**\n * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n * which invokes `iteratee` for `value` and each element of `array` to compute\n * their sort ranking. The iteratee is invoked with one argument; (value).\n *\n * @private\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} iteratee The iteratee invoked per element.\n * @param {boolean} [retHighest] Specify returning the highest qualified index.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n */\n function baseSortedIndexBy(array, value, iteratee, retHighest) {\n var low = 0,\n high = array == null ? 0 : array.length;\n if (high === 0) {\n return 0;\n }\n\n value = iteratee(value);\n var valIsNaN = value !== value,\n valIsNull = value === null,\n valIsSymbol = isSymbol(value),\n valIsUndefined = value === undefined;\n\n while (low < high) {\n var mid = nativeFloor((low + high) / 2),\n computed = iteratee(array[mid]),\n othIsDefined = computed !== undefined,\n othIsNull = computed === null,\n othIsReflexive = computed === computed,\n othIsSymbol = isSymbol(computed);\n\n if (valIsNaN) {\n var setLow = retHighest || othIsReflexive;\n } else if (valIsUndefined) {\n setLow = othIsReflexive && (retHighest || othIsDefined);\n } else if (valIsNull) {\n setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n } else if (valIsSymbol) {\n setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n } else if (othIsNull || othIsSymbol) {\n setLow = false;\n } else {\n setLow = retHighest ? (computed <= value) : (computed < value);\n }\n if (setLow) {\n low = mid + 1;\n } else {\n high = mid;\n }\n }\n return nativeMin(high, MAX_ARRAY_INDEX);\n }\n\n /**\n * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\n function baseSortedUniq(array, iteratee) {\n var index = -1,\n length = array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n if (!index || !eq(computed, seen)) {\n var seen = computed;\n result[resIndex++] = value === 0 ? 0 : value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.toNumber` which doesn't ensure correct\n * conversions of binary, hexadecimal, or octal string values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n */\n function baseToNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n return +value;\n }\n\n /**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\n function baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n }\n\n /**\n * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\n function baseUniq(array, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n length = array.length,\n isCommon = true,\n result = [],\n seen = result;\n\n if (comparator) {\n isCommon = false;\n includes = arrayIncludesWith;\n }\n else if (length >= LARGE_ARRAY_SIZE) {\n var set = iteratee ? null : createSet(array);\n if (set) {\n return setToArray(set);\n }\n isCommon = false;\n includes = cacheHas;\n seen = new SetCache;\n }\n else {\n seen = iteratee ? [] : result;\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var seenIndex = seen.length;\n while (seenIndex--) {\n if (seen[seenIndex] === computed) {\n continue outer;\n }\n }\n if (iteratee) {\n seen.push(computed);\n }\n result.push(value);\n }\n else if (!includes(seen, computed, comparator)) {\n if (seen !== result) {\n seen.push(computed);\n }\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.unset`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The property path to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n */\n function baseUnset(object, path) {\n path = castPath(path, object);\n object = parent(object, path);\n return object == null || delete object[toKey(last(path))];\n }\n\n /**\n * The base implementation of `_.update`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to update.\n * @param {Function} updater The function to produce the updated value.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\n function baseUpdate(object, path, updater, customizer) {\n return baseSet(object, path, updater(baseGet(object, path)), customizer);\n }\n\n /**\n * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n * without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to query.\n * @param {Function} predicate The function invoked per iteration.\n * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Array} Returns the slice of `array`.\n */\n function baseWhile(array, predicate, isDrop, fromRight) {\n var length = array.length,\n index = fromRight ? length : -1;\n\n while ((fromRight ? index-- : ++index < length) &&\n predicate(array[index], index, array)) {}\n\n return isDrop\n ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n }\n\n /**\n * The base implementation of `wrapperValue` which returns the result of\n * performing a sequence of actions on the unwrapped `value`, where each\n * successive action is supplied the return value of the previous.\n *\n * @private\n * @param {*} value The unwrapped value.\n * @param {Array} actions Actions to perform to resolve the unwrapped value.\n * @returns {*} Returns the resolved value.\n */\n function baseWrapperValue(value, actions) {\n var result = value;\n if (result instanceof LazyWrapper) {\n result = result.value();\n }\n return arrayReduce(actions, function(result, action) {\n return action.func.apply(action.thisArg, arrayPush([result], action.args));\n }, result);\n }\n\n /**\n * The base implementation of methods like `_.xor`, without support for\n * iteratee shorthands, that accepts an array of arrays to inspect.\n *\n * @private\n * @param {Array} arrays The arrays to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of values.\n */\n function baseXor(arrays, iteratee, comparator) {\n var length = arrays.length;\n if (length < 2) {\n return length ? baseUniq(arrays[0]) : [];\n }\n var index = -1,\n result = Array(length);\n\n while (++index < length) {\n var array = arrays[index],\n othIndex = -1;\n\n while (++othIndex < length) {\n if (othIndex != index) {\n result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n }\n }\n }\n return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n }\n\n /**\n * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n *\n * @private\n * @param {Array} props The property identifiers.\n * @param {Array} values The property values.\n * @param {Function} assignFunc The function to assign values.\n * @returns {Object} Returns the new object.\n */\n function baseZipObject(props, values, assignFunc) {\n var index = -1,\n length = props.length,\n valsLength = values.length,\n result = {};\n\n while (++index < length) {\n var value = index < valsLength ? values[index] : undefined;\n assignFunc(result, props[index], value);\n }\n return result;\n }\n\n /**\n * Casts `value` to an empty array if it's not an array like object.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Array|Object} Returns the cast array-like object.\n */\n function castArrayLikeObject(value) {\n return isArrayLikeObject(value) ? value : [];\n }\n\n /**\n * Casts `value` to `identity` if it's not a function.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Function} Returns cast function.\n */\n function castFunction(value) {\n return typeof value == 'function' ? value : identity;\n }\n\n /**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\n function castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n }\n\n /**\n * A `baseRest` alias which can be replaced with `identity` by module\n * replacement plugins.\n *\n * @private\n * @type {Function}\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\n var castRest = baseRest;\n\n /**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\n function castSlice(array, start, end) {\n var length = array.length;\n end = end === undefined ? length : end;\n return (!start && end >= length) ? array : baseSlice(array, start, end);\n }\n\n /**\n * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n *\n * @private\n * @param {number|Object} id The timer id or timeout object of the timer to clear.\n */\n var clearTimeout = ctxClearTimeout || function(id) {\n return root.clearTimeout(id);\n };\n\n /**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\n function cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n }\n\n /**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\n function cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n }\n\n /**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\n function cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n }\n\n /**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\n function cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n }\n\n /**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\n function cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n }\n\n /**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\n function cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n }\n\n /**\n * Compares values to sort them in ascending order.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {number} Returns the sort order indicator for `value`.\n */\n function compareAscending(value, other) {\n if (value !== other) {\n var valIsDefined = value !== undefined,\n valIsNull = value === null,\n valIsReflexive = value === value,\n valIsSymbol = isSymbol(value);\n\n var othIsDefined = other !== undefined,\n othIsNull = other === null,\n othIsReflexive = other === other,\n othIsSymbol = isSymbol(other);\n\n if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n (valIsNull && othIsDefined && othIsReflexive) ||\n (!valIsDefined && othIsReflexive) ||\n !valIsReflexive) {\n return 1;\n }\n if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n (othIsNull && valIsDefined && valIsReflexive) ||\n (!othIsDefined && valIsReflexive) ||\n !othIsReflexive) {\n return -1;\n }\n }\n return 0;\n }\n\n /**\n * Used by `_.orderBy` to compare multiple properties of a value to another\n * and stable sort them.\n *\n * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n * of corresponding values.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {boolean[]|string[]} orders The order to sort by for each property.\n * @returns {number} Returns the sort order indicator for `object`.\n */\n function compareMultiple(object, other, orders) {\n var index = -1,\n objCriteria = object.criteria,\n othCriteria = other.criteria,\n length = objCriteria.length,\n ordersLength = orders.length;\n\n while (++index < length) {\n var result = compareAscending(objCriteria[index], othCriteria[index]);\n if (result) {\n if (index >= ordersLength) {\n return result;\n }\n var order = orders[index];\n return result * (order == 'desc' ? -1 : 1);\n }\n }\n // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n // that causes it, under certain circumstances, to provide the same value for\n // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n // for more details.\n //\n // This also ensures a stable sort in V8 and other engines.\n // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n return object.index - other.index;\n }\n\n /**\n * Creates an array that is the composition of partially applied arguments,\n * placeholders, and provided arguments into a single array of arguments.\n *\n * @private\n * @param {Array} args The provided arguments.\n * @param {Array} partials The arguments to prepend to those provided.\n * @param {Array} holders The `partials` placeholder indexes.\n * @params {boolean} [isCurried] Specify composing for a curried function.\n * @returns {Array} Returns the new array of composed arguments.\n */\n function composeArgs(args, partials, holders, isCurried) {\n var argsIndex = -1,\n argsLength = args.length,\n holdersLength = holders.length,\n leftIndex = -1,\n leftLength = partials.length,\n rangeLength = nativeMax(argsLength - holdersLength, 0),\n result = Array(leftLength + rangeLength),\n isUncurried = !isCurried;\n\n while (++leftIndex < leftLength) {\n result[leftIndex] = partials[leftIndex];\n }\n while (++argsIndex < holdersLength) {\n if (isUncurried || argsIndex < argsLength) {\n result[holders[argsIndex]] = args[argsIndex];\n }\n }\n while (rangeLength--) {\n result[leftIndex++] = args[argsIndex++];\n }\n return result;\n }\n\n /**\n * This function is like `composeArgs` except that the arguments composition\n * is tailored for `_.partialRight`.\n *\n * @private\n * @param {Array} args The provided arguments.\n * @param {Array} partials The arguments to append to those provided.\n * @param {Array} holders The `partials` placeholder indexes.\n * @params {boolean} [isCurried] Specify composing for a curried function.\n * @returns {Array} Returns the new array of composed arguments.\n */\n function composeArgsRight(args, partials, holders, isCurried) {\n var argsIndex = -1,\n argsLength = args.length,\n holdersIndex = -1,\n holdersLength = holders.length,\n rightIndex = -1,\n rightLength = partials.length,\n rangeLength = nativeMax(argsLength - holdersLength, 0),\n result = Array(rangeLength + rightLength),\n isUncurried = !isCurried;\n\n while (++argsIndex < rangeLength) {\n result[argsIndex] = args[argsIndex];\n }\n var offset = argsIndex;\n while (++rightIndex < rightLength) {\n result[offset + rightIndex] = partials[rightIndex];\n }\n while (++holdersIndex < holdersLength) {\n if (isUncurried || argsIndex < argsLength) {\n result[offset + holders[holdersIndex]] = args[argsIndex++];\n }\n }\n return result;\n }\n\n /**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\n function copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n }\n\n /**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\n function copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n }\n\n /**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\n function copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n }\n\n /**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\n function copySymbolsIn(source, object) {\n return copyObject(source, getSymbolsIn(source), object);\n }\n\n /**\n * Creates a function like `_.groupBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} [initializer] The accumulator object initializer.\n * @returns {Function} Returns the new aggregator function.\n */\n function createAggregator(setter, initializer) {\n return function(collection, iteratee) {\n var func = isArray(collection) ? arrayAggregator : baseAggregator,\n accumulator = initializer ? initializer() : {};\n\n return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n };\n }\n\n /**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\n function createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n }\n\n /**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\n function createBaseEach(eachFunc, fromRight) {\n return function(collection, iteratee) {\n if (collection == null) {\n return collection;\n }\n if (!isArrayLike(collection)) {\n return eachFunc(collection, iteratee);\n }\n var length = collection.length,\n index = fromRight ? length : -1,\n iterable = Object(collection);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (iteratee(iterable[index], index, iterable) === false) {\n break;\n }\n }\n return collection;\n };\n }\n\n /**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\n function createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with the optional `this`\n * binding of `thisArg`.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createBind(func, bitmask, thisArg) {\n var isBind = bitmask & WRAP_BIND_FLAG,\n Ctor = createCtor(func);\n\n function wrapper() {\n var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n return fn.apply(isBind ? thisArg : this, arguments);\n }\n return wrapper;\n }\n\n /**\n * Creates a function like `_.lowerFirst`.\n *\n * @private\n * @param {string} methodName The name of the `String` case method to use.\n * @returns {Function} Returns the new case function.\n */\n function createCaseFirst(methodName) {\n return function(string) {\n string = toString(string);\n\n var strSymbols = hasUnicode(string)\n ? stringToArray(string)\n : undefined;\n\n var chr = strSymbols\n ? strSymbols[0]\n : string.charAt(0);\n\n var trailing = strSymbols\n ? castSlice(strSymbols, 1).join('')\n : string.slice(1);\n\n return chr[methodName]() + trailing;\n };\n }\n\n /**\n * Creates a function like `_.camelCase`.\n *\n * @private\n * @param {Function} callback The function to combine each word.\n * @returns {Function} Returns the new compounder function.\n */\n function createCompounder(callback) {\n return function(string) {\n return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n };\n }\n\n /**\n * Creates a function that produces an instance of `Ctor` regardless of\n * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n *\n * @private\n * @param {Function} Ctor The constructor to wrap.\n * @returns {Function} Returns the new wrapped function.\n */\n function createCtor(Ctor) {\n return function() {\n // Use a `switch` statement to work with class constructors. See\n // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n // for more details.\n var args = arguments;\n switch (args.length) {\n case 0: return new Ctor;\n case 1: return new Ctor(args[0]);\n case 2: return new Ctor(args[0], args[1]);\n case 3: return new Ctor(args[0], args[1], args[2]);\n case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n }\n var thisBinding = baseCreate(Ctor.prototype),\n result = Ctor.apply(thisBinding, args);\n\n // Mimic the constructor's `return` behavior.\n // See https://es5.github.io/#x13.2.2 for more details.\n return isObject(result) ? result : thisBinding;\n };\n }\n\n /**\n * Creates a function that wraps `func` to enable currying.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {number} arity The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createCurry(func, bitmask, arity) {\n var Ctor = createCtor(func);\n\n function wrapper() {\n var length = arguments.length,\n args = Array(length),\n index = length,\n placeholder = getHolder(wrapper);\n\n while (index--) {\n args[index] = arguments[index];\n }\n var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n ? []\n : replaceHolders(args, placeholder);\n\n length -= holders.length;\n if (length < arity) {\n return createRecurry(\n func, bitmask, createHybrid, wrapper.placeholder, undefined,\n args, holders, undefined, undefined, arity - length);\n }\n var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n return apply(fn, this, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} findIndexFunc The function to find the collection index.\n * @returns {Function} Returns the new find function.\n */\n function createFind(findIndexFunc) {\n return function(collection, predicate, fromIndex) {\n var iterable = Object(collection);\n if (!isArrayLike(collection)) {\n var iteratee = getIteratee(predicate, 3);\n collection = keys(collection);\n predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n }\n var index = findIndexFunc(collection, predicate, fromIndex);\n return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n };\n }\n\n /**\n * Creates a `_.flow` or `_.flowRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new flow function.\n */\n function createFlow(fromRight) {\n return flatRest(function(funcs) {\n var length = funcs.length,\n index = length,\n prereq = LodashWrapper.prototype.thru;\n\n if (fromRight) {\n funcs.reverse();\n }\n while (index--) {\n var func = funcs[index];\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n var wrapper = new LodashWrapper([], true);\n }\n }\n index = wrapper ? index : length;\n while (++index < length) {\n func = funcs[index];\n\n var funcName = getFuncName(func),\n data = funcName == 'wrapper' ? getData(func) : undefined;\n\n if (data && isLaziable(data[0]) &&\n data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n !data[4].length && data[9] == 1\n ) {\n wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n } else {\n wrapper = (func.length == 1 && isLaziable(func))\n ? wrapper[funcName]()\n : wrapper.thru(func);\n }\n }\n return function() {\n var args = arguments,\n value = args[0];\n\n if (wrapper && args.length == 1 && isArray(value)) {\n return wrapper.plant(value).value();\n }\n var index = 0,\n result = length ? funcs[index].apply(this, args) : value;\n\n while (++index < length) {\n result = funcs[index].call(this, result);\n }\n return result;\n };\n });\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with optional `this`\n * binding of `thisArg`, partial application, and currying.\n *\n * @private\n * @param {Function|string} func The function or method name to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to prepend to those provided to\n * the new function.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [partialsRight] The arguments to append to those provided\n * to the new function.\n * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n var isAry = bitmask & WRAP_ARY_FLAG,\n isBind = bitmask & WRAP_BIND_FLAG,\n isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n isFlip = bitmask & WRAP_FLIP_FLAG,\n Ctor = isBindKey ? undefined : createCtor(func);\n\n function wrapper() {\n var length = arguments.length,\n args = Array(length),\n index = length;\n\n while (index--) {\n args[index] = arguments[index];\n }\n if (isCurried) {\n var placeholder = getHolder(wrapper),\n holdersCount = countHolders(args, placeholder);\n }\n if (partials) {\n args = composeArgs(args, partials, holders, isCurried);\n }\n if (partialsRight) {\n args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n }\n length -= holdersCount;\n if (isCurried && length < arity) {\n var newHolders = replaceHolders(args, placeholder);\n return createRecurry(\n func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n args, newHolders, argPos, ary, arity - length\n );\n }\n var thisBinding = isBind ? thisArg : this,\n fn = isBindKey ? thisBinding[func] : func;\n\n length = args.length;\n if (argPos) {\n args = reorder(args, argPos);\n } else if (isFlip && length > 1) {\n args.reverse();\n }\n if (isAry && ary < length) {\n args.length = ary;\n }\n if (this && this !== root && this instanceof wrapper) {\n fn = Ctor || createCtor(fn);\n }\n return fn.apply(thisBinding, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a function like `_.invertBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} toIteratee The function to resolve iteratees.\n * @returns {Function} Returns the new inverter function.\n */\n function createInverter(setter, toIteratee) {\n return function(object, iteratee) {\n return baseInverter(object, setter, toIteratee(iteratee), {});\n };\n }\n\n /**\n * Creates a function that performs a mathematical operation on two values.\n *\n * @private\n * @param {Function} operator The function to perform the operation.\n * @param {number} [defaultValue] The value used for `undefined` arguments.\n * @returns {Function} Returns the new mathematical operation function.\n */\n function createMathOperation(operator, defaultValue) {\n return function(value, other) {\n var result;\n if (value === undefined && other === undefined) {\n return defaultValue;\n }\n if (value !== undefined) {\n result = value;\n }\n if (other !== undefined) {\n if (result === undefined) {\n return other;\n }\n if (typeof value == 'string' || typeof other == 'string') {\n value = baseToString(value);\n other = baseToString(other);\n } else {\n value = baseToNumber(value);\n other = baseToNumber(other);\n }\n result = operator(value, other);\n }\n return result;\n };\n }\n\n /**\n * Creates a function like `_.over`.\n *\n * @private\n * @param {Function} arrayFunc The function to iterate over iteratees.\n * @returns {Function} Returns the new over function.\n */\n function createOver(arrayFunc) {\n return flatRest(function(iteratees) {\n iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n return baseRest(function(args) {\n var thisArg = this;\n return arrayFunc(iteratees, function(iteratee) {\n return apply(iteratee, thisArg, args);\n });\n });\n });\n }\n\n /**\n * Creates the padding for `string` based on `length`. The `chars` string\n * is truncated if the number of characters exceeds `length`.\n *\n * @private\n * @param {number} length The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padding for `string`.\n */\n function createPadding(length, chars) {\n chars = chars === undefined ? ' ' : baseToString(chars);\n\n var charsLength = chars.length;\n if (charsLength < 2) {\n return charsLength ? baseRepeat(chars, length) : chars;\n }\n var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n return hasUnicode(chars)\n ? castSlice(stringToArray(result), 0, length).join('')\n : result.slice(0, length);\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with the `this` binding\n * of `thisArg` and `partials` prepended to the arguments it receives.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} partials The arguments to prepend to those provided to\n * the new function.\n * @returns {Function} Returns the new wrapped function.\n */\n function createPartial(func, bitmask, thisArg, partials) {\n var isBind = bitmask & WRAP_BIND_FLAG,\n Ctor = createCtor(func);\n\n function wrapper() {\n var argsIndex = -1,\n argsLength = arguments.length,\n leftIndex = -1,\n leftLength = partials.length,\n args = Array(leftLength + argsLength),\n fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n while (++leftIndex < leftLength) {\n args[leftIndex] = partials[leftIndex];\n }\n while (argsLength--) {\n args[leftIndex++] = arguments[++argsIndex];\n }\n return apply(fn, isBind ? thisArg : this, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a `_.range` or `_.rangeRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new range function.\n */\n function createRange(fromRight) {\n return function(start, end, step) {\n if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n end = step = undefined;\n }\n // Ensure the sign of `-0` is preserved.\n start = toFinite(start);\n if (end === undefined) {\n end = start;\n start = 0;\n } else {\n end = toFinite(end);\n }\n step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n return baseRange(start, end, step, fromRight);\n };\n }\n\n /**\n * Creates a function that performs a relational operation on two values.\n *\n * @private\n * @param {Function} operator The function to perform the operation.\n * @returns {Function} Returns the new relational operation function.\n */\n function createRelationalOperation(operator) {\n return function(value, other) {\n if (!(typeof value == 'string' && typeof other == 'string')) {\n value = toNumber(value);\n other = toNumber(other);\n }\n return operator(value, other);\n };\n }\n\n /**\n * Creates a function that wraps `func` to continue currying.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {Function} wrapFunc The function to create the `func` wrapper.\n * @param {*} placeholder The placeholder value.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to prepend to those provided to\n * the new function.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n var isCurry = bitmask & WRAP_CURRY_FLAG,\n newHolders = isCurry ? holders : undefined,\n newHoldersRight = isCurry ? undefined : holders,\n newPartials = isCurry ? partials : undefined,\n newPartialsRight = isCurry ? undefined : partials;\n\n bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n }\n var newData = [\n func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n newHoldersRight, argPos, ary, arity\n ];\n\n var result = wrapFunc.apply(undefined, newData);\n if (isLaziable(func)) {\n setData(result, newData);\n }\n result.placeholder = placeholder;\n return setWrapToString(result, func, bitmask);\n }\n\n /**\n * Creates a function like `_.round`.\n *\n * @private\n * @param {string} methodName The name of the `Math` method to use when rounding.\n * @returns {Function} Returns the new round function.\n */\n function createRound(methodName) {\n var func = Math[methodName];\n return function(number, precision) {\n number = toNumber(number);\n precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n if (precision && nativeIsFinite(number)) {\n // Shift with exponential notation to avoid floating-point issues.\n // See [MDN](https://mdn.io/round#Examples) for more details.\n var pair = (toString(number) + 'e').split('e'),\n value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n pair = (toString(value) + 'e').split('e');\n return +(pair[0] + 'e' + (+pair[1] - precision));\n }\n return func(number);\n };\n }\n\n /**\n * Creates a set object of `values`.\n *\n * @private\n * @param {Array} values The values to add to the set.\n * @returns {Object} Returns the new set.\n */\n var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n return new Set(values);\n };\n\n /**\n * Creates a `_.toPairs` or `_.toPairsIn` function.\n *\n * @private\n * @param {Function} keysFunc The function to get the keys of a given object.\n * @returns {Function} Returns the new pairs function.\n */\n function createToPairs(keysFunc) {\n return function(object) {\n var tag = getTag(object);\n if (tag == mapTag) {\n return mapToArray(object);\n }\n if (tag == setTag) {\n return setToPairs(object);\n }\n return baseToPairs(object, keysFunc(object));\n };\n }\n\n /**\n * Creates a function that either curries or invokes `func` with optional\n * `this` binding and partially applied arguments.\n *\n * @private\n * @param {Function|string} func The function or method name to wrap.\n * @param {number} bitmask The bitmask flags.\n * 1 - `_.bind`\n * 2 - `_.bindKey`\n * 4 - `_.curry` or `_.curryRight` of a bound function\n * 8 - `_.curry`\n * 16 - `_.curryRight`\n * 32 - `_.partial`\n * 64 - `_.partialRight`\n * 128 - `_.rearg`\n * 256 - `_.ary`\n * 512 - `_.flip`\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to be partially applied.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n if (!isBindKey && typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var length = partials ? partials.length : 0;\n if (!length) {\n bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n partials = holders = undefined;\n }\n ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n arity = arity === undefined ? arity : toInteger(arity);\n length -= holders ? holders.length : 0;\n\n if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n var partialsRight = partials,\n holdersRight = holders;\n\n partials = holders = undefined;\n }\n var data = isBindKey ? undefined : getData(func);\n\n var newData = [\n func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n argPos, ary, arity\n ];\n\n if (data) {\n mergeData(newData, data);\n }\n func = newData[0];\n bitmask = newData[1];\n thisArg = newData[2];\n partials = newData[3];\n holders = newData[4];\n arity = newData[9] = newData[9] === undefined\n ? (isBindKey ? 0 : func.length)\n : nativeMax(newData[9] - length, 0);\n\n if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n }\n if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n var result = createBind(func, bitmask, thisArg);\n } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n result = createCurry(func, bitmask, arity);\n } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n result = createPartial(func, bitmask, thisArg, partials);\n } else {\n result = createHybrid.apply(undefined, newData);\n }\n var setter = data ? baseSetData : setData;\n return setWrapToString(setter(result, newData), func, bitmask);\n }\n\n /**\n * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n * of source objects to the destination object for all destination properties\n * that resolve to `undefined`.\n *\n * @private\n * @param {*} objValue The destination value.\n * @param {*} srcValue The source value.\n * @param {string} key The key of the property to assign.\n * @param {Object} object The parent object of `objValue`.\n * @returns {*} Returns the value to assign.\n */\n function customDefaultsAssignIn(objValue, srcValue, key, object) {\n if (objValue === undefined ||\n (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n return srcValue;\n }\n return objValue;\n }\n\n /**\n * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n * objects into destination objects that are passed thru.\n *\n * @private\n * @param {*} objValue The destination value.\n * @param {*} srcValue The source value.\n * @param {string} key The key of the property to merge.\n * @param {Object} object The parent object of `objValue`.\n * @param {Object} source The parent object of `srcValue`.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n * @returns {*} Returns the value to assign.\n */\n function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n if (isObject(objValue) && isObject(srcValue)) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, objValue);\n baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n stack['delete'](srcValue);\n }\n return objValue;\n }\n\n /**\n * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n * objects.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {string} key The key of the property to inspect.\n * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n */\n function customOmitClone(value) {\n return isPlainObject(value) ? undefined : value;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\n function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\n function flatRest(func) {\n return setToString(overRest(func, undefined, flatten), func + '');\n }\n\n /**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n }\n\n /**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeysIn(object) {\n return baseGetAllKeys(object, keysIn, getSymbolsIn);\n }\n\n /**\n * Gets metadata for `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {*} Returns the metadata for `func`.\n */\n var getData = !metaMap ? noop : function(func) {\n return metaMap.get(func);\n };\n\n /**\n * Gets the name of `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {string} Returns the function name.\n */\n function getFuncName(func) {\n var result = (func.name + ''),\n array = realNames[result],\n length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n while (length--) {\n var data = array[length],\n otherFunc = data.func;\n if (otherFunc == null || otherFunc == func) {\n return data.name;\n }\n }\n return result;\n }\n\n /**\n * Gets the argument placeholder value for `func`.\n *\n * @private\n * @param {Function} func The function to inspect.\n * @returns {*} Returns the placeholder value.\n */\n function getHolder(func) {\n var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n return object.placeholder;\n }\n\n /**\n * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n * this function returns the custom method, otherwise it returns `baseIteratee`.\n * If arguments are provided, the chosen function is invoked with them and\n * its result is returned.\n *\n * @private\n * @param {*} [value] The value to convert to an iteratee.\n * @param {number} [arity] The arity of the created iteratee.\n * @returns {Function} Returns the chosen function or its result.\n */\n function getIteratee() {\n var result = lodash.iteratee || iteratee;\n result = result === iteratee ? baseIteratee : result;\n return arguments.length ? result(arguments[0], arguments[1]) : result;\n }\n\n /**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\n function getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n }\n\n /**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\n function getMatchData(object) {\n var result = keys(object),\n length = result.length;\n\n while (length--) {\n var key = result[length],\n value = object[key];\n\n result[length] = [key, value, isStrictComparable(value)];\n }\n return result;\n }\n\n /**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\n function getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n }\n\n /**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\n function getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n }\n\n /**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n };\n\n /**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n var result = [];\n while (object) {\n arrayPush(result, getSymbols(object));\n object = getPrototype(object);\n }\n return result;\n };\n\n /**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\n var getTag = baseGetTag;\n\n // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n }\n\n /**\n * Gets the view, applying any `transforms` to the `start` and `end` positions.\n *\n * @private\n * @param {number} start The start of the view.\n * @param {number} end The end of the view.\n * @param {Array} transforms The transformations to apply to the view.\n * @returns {Object} Returns an object containing the `start` and `end`\n * positions of the view.\n */\n function getView(start, end, transforms) {\n var index = -1,\n length = transforms.length;\n\n while (++index < length) {\n var data = transforms[index],\n size = data.size;\n\n switch (data.type) {\n case 'drop': start += size; break;\n case 'dropRight': end -= size; break;\n case 'take': end = nativeMin(end, start + size); break;\n case 'takeRight': start = nativeMax(start, end - size); break;\n }\n }\n return { 'start': start, 'end': end };\n }\n\n /**\n * Extracts wrapper details from the `source` body comment.\n *\n * @private\n * @param {string} source The source to inspect.\n * @returns {Array} Returns the wrapper details.\n */\n function getWrapDetails(source) {\n var match = source.match(reWrapDetails);\n return match ? match[1].split(reSplitDetails) : [];\n }\n\n /**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\n function hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n }\n\n /**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\n function initCloneArray(array) {\n var length = array.length,\n result = new array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n }\n\n /**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n }\n\n /**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneByTag(object, tag, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return new Ctor;\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return new Ctor;\n\n case symbolTag:\n return cloneSymbol(object);\n }\n }\n\n /**\n * Inserts wrapper `details` in a comment at the top of the `source` body.\n *\n * @private\n * @param {string} source The source to modify.\n * @returns {Array} details The details to insert.\n * @returns {string} Returns the modified source.\n */\n function insertWrapDetails(source, details) {\n var length = details.length;\n if (!length) {\n return source;\n }\n var lastIndex = length - 1;\n details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n details = details.join(length > 2 ? ', ' : ' ');\n return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n }\n\n /**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\n function isFlattenable(value) {\n return isArray(value) || isArguments(value) ||\n !!(spreadableSymbol && value && value[spreadableSymbol]);\n }\n\n /**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\n function isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n }\n\n /**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\n function isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n }\n\n /**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\n function isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n }\n\n /**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\n function isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n }\n\n /**\n * Checks if `func` has a lazy counterpart.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n * else `false`.\n */\n function isLaziable(func) {\n var funcName = getFuncName(func),\n other = lodash[funcName];\n\n if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n return false;\n }\n if (func === other) {\n return true;\n }\n var data = getData(other);\n return !!data && func === data[0];\n }\n\n /**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\n function isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n }\n\n /**\n * Checks if `func` is capable of being masked.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n */\n var isMaskable = coreJsData ? isFunction : stubFalse;\n\n /**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\n function isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n }\n\n /**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n * equality comparisons, else `false`.\n */\n function isStrictComparable(value) {\n return value === value && !isObject(value);\n }\n\n /**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function matchesStrictComparable(key, srcValue) {\n return function(object) {\n if (object == null) {\n return false;\n }\n return object[key] === srcValue &&\n (srcValue !== undefined || (key in Object(object)));\n };\n }\n\n /**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\n function memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n }\n\n /**\n * Merges the function metadata of `source` into `data`.\n *\n * Merging metadata reduces the number of wrappers used to invoke a function.\n * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n * may be applied regardless of execution order. Methods like `_.ary` and\n * `_.rearg` modify function arguments, making the order in which they are\n * executed important, preventing the merging of metadata. However, we make\n * an exception for a safe combined case where curried functions have `_.ary`\n * and or `_.rearg` applied.\n *\n * @private\n * @param {Array} data The destination metadata.\n * @param {Array} source The source metadata.\n * @returns {Array} Returns `data`.\n */\n function mergeData(data, source) {\n var bitmask = data[1],\n srcBitmask = source[1],\n newBitmask = bitmask | srcBitmask,\n isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n var isCombo =\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n // Exit early if metadata can't be merged.\n if (!(isCommon || isCombo)) {\n return data;\n }\n // Use source `thisArg` if available.\n if (srcBitmask & WRAP_BIND_FLAG) {\n data[2] = source[2];\n // Set when currying a bound function.\n newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n }\n // Compose partial arguments.\n var value = source[3];\n if (value) {\n var partials = data[3];\n data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n }\n // Compose partial right arguments.\n value = source[5];\n if (value) {\n partials = data[5];\n data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n }\n // Use source `argPos` if available.\n value = source[7];\n if (value) {\n data[7] = value;\n }\n // Use source `ary` if it's smaller.\n if (srcBitmask & WRAP_ARY_FLAG) {\n data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n }\n // Use source `arity` if one is not provided.\n if (data[9] == null) {\n data[9] = source[9];\n }\n // Use source `func` and merge bitmasks.\n data[0] = source[0];\n data[1] = newBitmask;\n\n return data;\n }\n\n /**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\n function objectToString(value) {\n return nativeObjectToString.call(value);\n }\n\n /**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\n function overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n }\n\n /**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\n function parent(object, path) {\n return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n }\n\n /**\n * Reorder `array` according to the specified indexes where the element at\n * the first index is assigned as the first element, the element at\n * the second index is assigned as the second element, and so on.\n *\n * @private\n * @param {Array} array The array to reorder.\n * @param {Array} indexes The arranged array indexes.\n * @returns {Array} Returns `array`.\n */\n function reorder(array, indexes) {\n var arrLength = array.length,\n length = nativeMin(indexes.length, arrLength),\n oldArray = copyArray(array);\n\n while (length--) {\n var index = indexes[length];\n array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n }\n return array;\n }\n\n /**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n function safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n }\n\n /**\n * Sets metadata for `func`.\n *\n * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n * period of time, it will trip its breaker and transition to an identity\n * function to avoid garbage collection pauses in V8. See\n * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n * for more details.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var setData = shortOut(baseSetData);\n\n /**\n * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\n var setTimeout = ctxSetTimeout || function(func, wait) {\n return root.setTimeout(func, wait);\n };\n\n /**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n var setToString = shortOut(baseSetToString);\n\n /**\n * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n * with wrapper details in a comment at the top of the source body.\n *\n * @private\n * @param {Function} wrapper The function to modify.\n * @param {Function} reference The reference function.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @returns {Function} Returns `wrapper`.\n */\n function setWrapToString(wrapper, reference, bitmask) {\n var source = (reference + '');\n return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n }\n\n /**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\n function shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n }\n\n /**\n * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n *\n * @private\n * @param {Array} array The array to shuffle.\n * @param {number} [size=array.length] The size of `array`.\n * @returns {Array} Returns `array`.\n */\n function shuffleSelf(array, size) {\n var index = -1,\n length = array.length,\n lastIndex = length - 1;\n\n size = size === undefined ? length : size;\n while (++index < size) {\n var rand = baseRandom(index, lastIndex),\n value = array[rand];\n\n array[rand] = array[index];\n array[index] = value;\n }\n array.length = size;\n return array;\n }\n\n /**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\n var stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n });\n\n /**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\n function toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n }\n\n /**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\n function toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n }\n\n /**\n * Updates wrapper `details` based on `bitmask` flags.\n *\n * @private\n * @returns {Array} details The details to modify.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @returns {Array} Returns `details`.\n */\n function updateWrapDetails(details, bitmask) {\n arrayEach(wrapFlags, function(pair) {\n var value = '_.' + pair[0];\n if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n details.push(value);\n }\n });\n return details.sort();\n }\n\n /**\n * Creates a clone of `wrapper`.\n *\n * @private\n * @param {Object} wrapper The wrapper to clone.\n * @returns {Object} Returns the cloned wrapper.\n */\n function wrapperClone(wrapper) {\n if (wrapper instanceof LazyWrapper) {\n return wrapper.clone();\n }\n var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n result.__actions__ = copyArray(wrapper.__actions__);\n result.__index__ = wrapper.__index__;\n result.__values__ = wrapper.__values__;\n return result;\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an array of elements split into groups the length of `size`.\n * If `array` can't be split evenly, the final chunk will be the remaining\n * elements.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to process.\n * @param {number} [size=1] The length of each chunk\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the new array of chunks.\n * @example\n *\n * _.chunk(['a', 'b', 'c', 'd'], 2);\n * // => [['a', 'b'], ['c', 'd']]\n *\n * _.chunk(['a', 'b', 'c', 'd'], 3);\n * // => [['a', 'b', 'c'], ['d']]\n */\n function chunk(array, size, guard) {\n if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n size = 1;\n } else {\n size = nativeMax(toInteger(size), 0);\n }\n var length = array == null ? 0 : array.length;\n if (!length || size < 1) {\n return [];\n }\n var index = 0,\n resIndex = 0,\n result = Array(nativeCeil(length / size));\n\n while (index < length) {\n result[resIndex++] = baseSlice(array, index, (index += size));\n }\n return result;\n }\n\n /**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\n function compact(array) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (value) {\n result[resIndex++] = value;\n }\n }\n return result;\n }\n\n /**\n * Creates a new array concatenating `array` with any additional arrays\n * and/or values.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to concatenate.\n * @param {...*} [values] The values to concatenate.\n * @returns {Array} Returns the new concatenated array.\n * @example\n *\n * var array = [1];\n * var other = _.concat(array, 2, [3], [[4]]);\n *\n * console.log(other);\n * // => [1, 2, 3, [4]]\n *\n * console.log(array);\n * // => [1]\n */\n function concat() {\n var length = arguments.length;\n if (!length) {\n return [];\n }\n var args = Array(length - 1),\n array = arguments[0],\n index = length;\n\n while (index--) {\n args[index - 1] = arguments[index];\n }\n return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n }\n\n /**\n * Creates an array of `array` values not included in the other given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * **Note:** Unlike `_.pullAll`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.without, _.xor\n * @example\n *\n * _.difference([2, 1], [2, 3]);\n * // => [1]\n */\n var difference = baseRest(function(array, values) {\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n : [];\n });\n\n /**\n * This method is like `_.difference` except that it accepts `iteratee` which\n * is invoked for each element of `array` and `values` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array. The iteratee is invoked with one argument:\n * (value).\n *\n * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n * // => [{ 'x': 2 }]\n */\n var differenceBy = baseRest(function(array, values) {\n var iteratee = last(values);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n : [];\n });\n\n /**\n * This method is like `_.difference` except that it accepts `comparator`\n * which is invoked to compare elements of `array` to `values`. The order and\n * references of result values are determined by the first array. The comparator\n * is invoked with two arguments: (arrVal, othVal).\n *\n * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n *\n * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n * // => [{ 'x': 2, 'y': 1 }]\n */\n var differenceWith = baseRest(function(array, values) {\n var comparator = last(values);\n if (isArrayLikeObject(comparator)) {\n comparator = undefined;\n }\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n : [];\n });\n\n /**\n * Creates a slice of `array` with `n` elements dropped from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.drop([1, 2, 3]);\n * // => [2, 3]\n *\n * _.drop([1, 2, 3], 2);\n * // => [3]\n *\n * _.drop([1, 2, 3], 5);\n * // => []\n *\n * _.drop([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\n function drop(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n return baseSlice(array, n < 0 ? 0 : n, length);\n }\n\n /**\n * Creates a slice of `array` with `n` elements dropped from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.dropRight([1, 2, 3]);\n * // => [1, 2]\n *\n * _.dropRight([1, 2, 3], 2);\n * // => [1]\n *\n * _.dropRight([1, 2, 3], 5);\n * // => []\n *\n * _.dropRight([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\n function dropRight(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n n = length - n;\n return baseSlice(array, 0, n < 0 ? 0 : n);\n }\n\n /**\n * Creates a slice of `array` excluding elements dropped from the end.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.dropRightWhile(users, function(o) { return !o.active; });\n * // => objects for ['barney']\n *\n * // The `_.matches` iteratee shorthand.\n * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n * // => objects for ['barney', 'fred']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.dropRightWhile(users, ['active', false]);\n * // => objects for ['barney']\n *\n * // The `_.property` iteratee shorthand.\n * _.dropRightWhile(users, 'active');\n * // => objects for ['barney', 'fred', 'pebbles']\n */\n function dropRightWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), true, true)\n : [];\n }\n\n /**\n * Creates a slice of `array` excluding elements dropped from the beginning.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.dropWhile(users, function(o) { return !o.active; });\n * // => objects for ['pebbles']\n *\n * // The `_.matches` iteratee shorthand.\n * _.dropWhile(users, { 'user': 'barney', 'active': false });\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.dropWhile(users, ['active', false]);\n * // => objects for ['pebbles']\n *\n * // The `_.property` iteratee shorthand.\n * _.dropWhile(users, 'active');\n * // => objects for ['barney', 'fred', 'pebbles']\n */\n function dropWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), true)\n : [];\n }\n\n /**\n * Fills elements of `array` with `value` from `start` up to, but not\n * including, `end`.\n *\n * **Note:** This method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Array\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _.fill(array, 'a');\n * console.log(array);\n * // => ['a', 'a', 'a']\n *\n * _.fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * _.fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n */\n function fill(array, value, start, end) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n start = 0;\n end = length;\n }\n return baseFill(array, value, start, end);\n }\n\n /**\n * This method is like `_.find` except that it returns the index of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.findIndex(users, function(o) { return o.user == 'barney'; });\n * // => 0\n *\n * // The `_.matches` iteratee shorthand.\n * _.findIndex(users, { 'user': 'fred', 'active': false });\n * // => 1\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findIndex(users, ['active', false]);\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.findIndex(users, 'active');\n * // => 2\n */\n function findIndex(array, predicate, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = fromIndex == null ? 0 : toInteger(fromIndex);\n if (index < 0) {\n index = nativeMax(length + index, 0);\n }\n return baseFindIndex(array, getIteratee(predicate, 3), index);\n }\n\n /**\n * This method is like `_.findIndex` except that it iterates over elements\n * of `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=array.length-1] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n * // => 2\n *\n * // The `_.matches` iteratee shorthand.\n * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n * // => 0\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findLastIndex(users, ['active', false]);\n * // => 2\n *\n * // The `_.property` iteratee shorthand.\n * _.findLastIndex(users, 'active');\n * // => 0\n */\n function findLastIndex(array, predicate, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = length - 1;\n if (fromIndex !== undefined) {\n index = toInteger(fromIndex);\n index = fromIndex < 0\n ? nativeMax(length + index, 0)\n : nativeMin(index, length - 1);\n }\n return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n }\n\n /**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\n function flatten(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, 1) : [];\n }\n\n /**\n * Recursively flattens `array`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flattenDeep([1, [2, [3, [4]], 5]]);\n * // => [1, 2, 3, 4, 5]\n */\n function flattenDeep(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, INFINITY) : [];\n }\n\n /**\n * Recursively flatten `array` up to `depth` times.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @param {number} [depth=1] The maximum recursion depth.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * var array = [1, [2, [3, [4]], 5]];\n *\n * _.flattenDepth(array, 1);\n * // => [1, 2, [3, [4]], 5]\n *\n * _.flattenDepth(array, 2);\n * // => [1, 2, 3, [4], 5]\n */\n function flattenDepth(array, depth) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n depth = depth === undefined ? 1 : toInteger(depth);\n return baseFlatten(array, depth);\n }\n\n /**\n * The inverse of `_.toPairs`; this method returns an object composed\n * from key-value `pairs`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} pairs The key-value pairs.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.fromPairs([['a', 1], ['b', 2]]);\n * // => { 'a': 1, 'b': 2 }\n */\n function fromPairs(pairs) {\n var index = -1,\n length = pairs == null ? 0 : pairs.length,\n result = {};\n\n while (++index < length) {\n var pair = pairs[index];\n result[pair[0]] = pair[1];\n }\n return result;\n }\n\n /**\n * Gets the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias first\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the first element of `array`.\n * @example\n *\n * _.head([1, 2, 3]);\n * // => 1\n *\n * _.head([]);\n * // => undefined\n */\n function head(array) {\n return (array && array.length) ? array[0] : undefined;\n }\n\n /**\n * Gets the index at which the first occurrence of `value` is found in `array`\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. If `fromIndex` is negative, it's used as the\n * offset from the end of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.indexOf([1, 2, 1, 2], 2);\n * // => 1\n *\n * // Search from the `fromIndex`.\n * _.indexOf([1, 2, 1, 2], 2, 2);\n * // => 3\n */\n function indexOf(array, value, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = fromIndex == null ? 0 : toInteger(fromIndex);\n if (index < 0) {\n index = nativeMax(length + index, 0);\n }\n return baseIndexOf(array, value, index);\n }\n\n /**\n * Gets all but the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.initial([1, 2, 3]);\n * // => [1, 2]\n */\n function initial(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseSlice(array, 0, -1) : [];\n }\n\n /**\n * Creates an array of unique values that are included in all given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * _.intersection([2, 1], [2, 3]);\n * // => [2]\n */\n var intersection = baseRest(function(arrays) {\n var mapped = arrayMap(arrays, castArrayLikeObject);\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped)\n : [];\n });\n\n /**\n * This method is like `_.intersection` except that it accepts `iteratee`\n * which is invoked for each element of each `arrays` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [2.1]\n *\n * // The `_.property` iteratee shorthand.\n * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }]\n */\n var intersectionBy = baseRest(function(arrays) {\n var iteratee = last(arrays),\n mapped = arrayMap(arrays, castArrayLikeObject);\n\n if (iteratee === last(mapped)) {\n iteratee = undefined;\n } else {\n mapped.pop();\n }\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped, getIteratee(iteratee, 2))\n : [];\n });\n\n /**\n * This method is like `_.intersection` except that it accepts `comparator`\n * which is invoked to compare elements of `arrays`. The order and references\n * of result values are determined by the first array. The comparator is\n * invoked with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.intersectionWith(objects, others, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }]\n */\n var intersectionWith = baseRest(function(arrays) {\n var comparator = last(arrays),\n mapped = arrayMap(arrays, castArrayLikeObject);\n\n comparator = typeof comparator == 'function' ? comparator : undefined;\n if (comparator) {\n mapped.pop();\n }\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped, undefined, comparator)\n : [];\n });\n\n /**\n * Converts all elements in `array` into a string separated by `separator`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to convert.\n * @param {string} [separator=','] The element separator.\n * @returns {string} Returns the joined string.\n * @example\n *\n * _.join(['a', 'b', 'c'], '~');\n * // => 'a~b~c'\n */\n function join(array, separator) {\n return array == null ? '' : nativeJoin.call(array, separator);\n }\n\n /**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\n function last(array) {\n var length = array == null ? 0 : array.length;\n return length ? array[length - 1] : undefined;\n }\n\n /**\n * This method is like `_.indexOf` except that it iterates over elements of\n * `array` from right to left.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=array.length-1] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.lastIndexOf([1, 2, 1, 2], 2);\n * // => 3\n *\n * // Search from the `fromIndex`.\n * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n * // => 1\n */\n function lastIndexOf(array, value, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = length;\n if (fromIndex !== undefined) {\n index = toInteger(fromIndex);\n index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n }\n return value === value\n ? strictLastIndexOf(array, value, index)\n : baseFindIndex(array, baseIsNaN, index, true);\n }\n\n /**\n * Gets the element at index `n` of `array`. If `n` is negative, the nth\n * element from the end is returned.\n *\n * @static\n * @memberOf _\n * @since 4.11.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=0] The index of the element to return.\n * @returns {*} Returns the nth element of `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'd'];\n *\n * _.nth(array, 1);\n * // => 'b'\n *\n * _.nth(array, -2);\n * // => 'c';\n */\n function nth(array, n) {\n return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n }\n\n /**\n * Removes all given values from `array` using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n * to remove elements from an array by predicate.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {...*} [values] The values to remove.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n *\n * _.pull(array, 'a', 'c');\n * console.log(array);\n * // => ['b', 'b']\n */\n var pull = baseRest(pullAll);\n\n /**\n * This method is like `_.pull` except that it accepts an array of values to remove.\n *\n * **Note:** Unlike `_.difference`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n *\n * _.pullAll(array, ['a', 'c']);\n * console.log(array);\n * // => ['b', 'b']\n */\n function pullAll(array, values) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values)\n : array;\n }\n\n /**\n * This method is like `_.pullAll` except that it accepts `iteratee` which is\n * invoked for each element of `array` and `values` to generate the criterion\n * by which they're compared. The iteratee is invoked with one argument: (value).\n *\n * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n *\n * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n * console.log(array);\n * // => [{ 'x': 2 }]\n */\n function pullAllBy(array, values, iteratee) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values, getIteratee(iteratee, 2))\n : array;\n }\n\n /**\n * This method is like `_.pullAll` except that it accepts `comparator` which\n * is invoked to compare elements of `array` to `values`. The comparator is\n * invoked with two arguments: (arrVal, othVal).\n *\n * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n *\n * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n * console.log(array);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n */\n function pullAllWith(array, values, comparator) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values, undefined, comparator)\n : array;\n }\n\n /**\n * Removes elements from `array` corresponding to `indexes` and returns an\n * array of removed elements.\n *\n * **Note:** Unlike `_.at`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n * @returns {Array} Returns the new array of removed elements.\n * @example\n *\n * var array = ['a', 'b', 'c', 'd'];\n * var pulled = _.pullAt(array, [1, 3]);\n *\n * console.log(array);\n * // => ['a', 'c']\n *\n * console.log(pulled);\n * // => ['b', 'd']\n */\n var pullAt = flatRest(function(array, indexes) {\n var length = array == null ? 0 : array.length,\n result = baseAt(array, indexes);\n\n basePullAt(array, arrayMap(indexes, function(index) {\n return isIndex(index, length) ? +index : index;\n }).sort(compareAscending));\n\n return result;\n });\n\n /**\n * Removes all elements from `array` that `predicate` returns truthy for\n * and returns an array of the removed elements. The predicate is invoked\n * with three arguments: (value, index, array).\n *\n * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n * to pull elements from an array by value.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new array of removed elements.\n * @example\n *\n * var array = [1, 2, 3, 4];\n * var evens = _.remove(array, function(n) {\n * return n % 2 == 0;\n * });\n *\n * console.log(array);\n * // => [1, 3]\n *\n * console.log(evens);\n * // => [2, 4]\n */\n function remove(array, predicate) {\n var result = [];\n if (!(array && array.length)) {\n return result;\n }\n var index = -1,\n indexes = [],\n length = array.length;\n\n predicate = getIteratee(predicate, 3);\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result.push(value);\n indexes.push(index);\n }\n }\n basePullAt(array, indexes);\n return result;\n }\n\n /**\n * Reverses `array` so that the first element becomes the last, the second\n * element becomes the second to last, and so on.\n *\n * **Note:** This method mutates `array` and is based on\n * [`Array#reverse`](https://mdn.io/Array/reverse).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _.reverse(array);\n * // => [3, 2, 1]\n *\n * console.log(array);\n * // => [3, 2, 1]\n */\n function reverse(array) {\n return array == null ? array : nativeReverse.call(array);\n }\n\n /**\n * Creates a slice of `array` from `start` up to, but not including, `end`.\n *\n * **Note:** This method is used instead of\n * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n * returned.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\n function slice(array, start, end) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n start = 0;\n end = length;\n }\n else {\n start = start == null ? 0 : toInteger(start);\n end = end === undefined ? length : toInteger(end);\n }\n return baseSlice(array, start, end);\n }\n\n /**\n * Uses a binary search to determine the lowest index at which `value`\n * should be inserted into `array` in order to maintain its sort order.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * _.sortedIndex([30, 50], 40);\n * // => 1\n */\n function sortedIndex(array, value) {\n return baseSortedIndex(array, value);\n }\n\n /**\n * This method is like `_.sortedIndex` except that it accepts `iteratee`\n * which is invoked for `value` and each element of `array` to compute their\n * sort ranking. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * var objects = [{ 'x': 4 }, { 'x': 5 }];\n *\n * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n * // => 0\n */\n function sortedIndexBy(array, value, iteratee) {\n return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n }\n\n /**\n * This method is like `_.indexOf` except that it performs a binary\n * search on a sorted `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n * // => 1\n */\n function sortedIndexOf(array, value) {\n var length = array == null ? 0 : array.length;\n if (length) {\n var index = baseSortedIndex(array, value);\n if (index < length && eq(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * This method is like `_.sortedIndex` except that it returns the highest\n * index at which `value` should be inserted into `array` in order to\n * maintain its sort order.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n * // => 4\n */\n function sortedLastIndex(array, value) {\n return baseSortedIndex(array, value, true);\n }\n\n /**\n * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n * which is invoked for `value` and each element of `array` to compute their\n * sort ranking. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * var objects = [{ 'x': 4 }, { 'x': 5 }];\n *\n * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n * // => 1\n *\n * // The `_.property` iteratee shorthand.\n * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n * // => 1\n */\n function sortedLastIndexBy(array, value, iteratee) {\n return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n }\n\n /**\n * This method is like `_.lastIndexOf` except that it performs a binary\n * search on a sorted `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n * // => 3\n */\n function sortedLastIndexOf(array, value) {\n var length = array == null ? 0 : array.length;\n if (length) {\n var index = baseSortedIndex(array, value, true) - 1;\n if (eq(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * This method is like `_.uniq` except that it's designed and optimized\n * for sorted arrays.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.sortedUniq([1, 1, 2]);\n * // => [1, 2]\n */\n function sortedUniq(array) {\n return (array && array.length)\n ? baseSortedUniq(array)\n : [];\n }\n\n /**\n * This method is like `_.uniqBy` except that it's designed and optimized\n * for sorted arrays.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n * // => [1.1, 2.3]\n */\n function sortedUniqBy(array, iteratee) {\n return (array && array.length)\n ? baseSortedUniq(array, getIteratee(iteratee, 2))\n : [];\n }\n\n /**\n * Gets all but the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.tail([1, 2, 3]);\n * // => [2, 3]\n */\n function tail(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseSlice(array, 1, length) : [];\n }\n\n /**\n * Creates a slice of `array` with `n` elements taken from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to take.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.take([1, 2, 3]);\n * // => [1]\n *\n * _.take([1, 2, 3], 2);\n * // => [1, 2]\n *\n * _.take([1, 2, 3], 5);\n * // => [1, 2, 3]\n *\n * _.take([1, 2, 3], 0);\n * // => []\n */\n function take(array, n, guard) {\n if (!(array && array.length)) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n return baseSlice(array, 0, n < 0 ? 0 : n);\n }\n\n /**\n * Creates a slice of `array` with `n` elements taken from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to take.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.takeRight([1, 2, 3]);\n * // => [3]\n *\n * _.takeRight([1, 2, 3], 2);\n * // => [2, 3]\n *\n * _.takeRight([1, 2, 3], 5);\n * // => [1, 2, 3]\n *\n * _.takeRight([1, 2, 3], 0);\n * // => []\n */\n function takeRight(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n n = length - n;\n return baseSlice(array, n < 0 ? 0 : n, length);\n }\n\n /**\n * Creates a slice of `array` with elements taken from the end. Elements are\n * taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.takeRightWhile(users, function(o) { return !o.active; });\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.matches` iteratee shorthand.\n * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n * // => objects for ['pebbles']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.takeRightWhile(users, ['active', false]);\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.property` iteratee shorthand.\n * _.takeRightWhile(users, 'active');\n * // => []\n */\n function takeRightWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), false, true)\n : [];\n }\n\n /**\n * Creates a slice of `array` with elements taken from the beginning. Elements\n * are taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.takeWhile(users, function(o) { return !o.active; });\n * // => objects for ['barney', 'fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.takeWhile(users, { 'user': 'barney', 'active': false });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.takeWhile(users, ['active', false]);\n * // => objects for ['barney', 'fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.takeWhile(users, 'active');\n * // => []\n */\n function takeWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3))\n : [];\n }\n\n /**\n * Creates an array of unique values, in order, from all given arrays using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * _.union([2], [1, 2]);\n * // => [2, 1]\n */\n var union = baseRest(function(arrays) {\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n });\n\n /**\n * This method is like `_.union` except that it accepts `iteratee` which is\n * invoked for each element of each `arrays` to generate the criterion by\n * which uniqueness is computed. Result values are chosen from the first\n * array in which the value occurs. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\n var unionBy = baseRest(function(arrays) {\n var iteratee = last(arrays);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n });\n\n /**\n * This method is like `_.union` except that it accepts `comparator` which\n * is invoked to compare elements of `arrays`. Result values are chosen from\n * the first array in which the value occurs. The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.unionWith(objects, others, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n */\n var unionWith = baseRest(function(arrays) {\n var comparator = last(arrays);\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n });\n\n /**\n * Creates a duplicate-free version of an array, using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons, in which only the first occurrence of each element\n * is kept. The order of result values is determined by the order they occur\n * in the array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniq([2, 1, 2]);\n * // => [2, 1]\n */\n function uniq(array) {\n return (array && array.length) ? baseUniq(array) : [];\n }\n\n /**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\n function uniqBy(array, iteratee) {\n return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n }\n\n /**\n * This method is like `_.uniq` except that it accepts `comparator` which\n * is invoked to compare elements of `array`. The order of result values is\n * determined by the order they occur in the array.The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.uniqWith(objects, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n */\n function uniqWith(array, comparator) {\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n }\n\n /**\n * This method is like `_.zip` except that it accepts an array of grouped\n * elements and creates an array regrouping the elements to their pre-zip\n * configuration.\n *\n * @static\n * @memberOf _\n * @since 1.2.0\n * @category Array\n * @param {Array} array The array of grouped elements to process.\n * @returns {Array} Returns the new array of regrouped elements.\n * @example\n *\n * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n * // => [['a', 1, true], ['b', 2, false]]\n *\n * _.unzip(zipped);\n * // => [['a', 'b'], [1, 2], [true, false]]\n */\n function unzip(array) {\n if (!(array && array.length)) {\n return [];\n }\n var length = 0;\n array = arrayFilter(array, function(group) {\n if (isArrayLikeObject(group)) {\n length = nativeMax(group.length, length);\n return true;\n }\n });\n return baseTimes(length, function(index) {\n return arrayMap(array, baseProperty(index));\n });\n }\n\n /**\n * This method is like `_.unzip` except that it accepts `iteratee` to specify\n * how regrouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Array\n * @param {Array} array The array of grouped elements to process.\n * @param {Function} [iteratee=_.identity] The function to combine\n * regrouped values.\n * @returns {Array} Returns the new array of regrouped elements.\n * @example\n *\n * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n * // => [[1, 10, 100], [2, 20, 200]]\n *\n * _.unzipWith(zipped, _.add);\n * // => [3, 30, 300]\n */\n function unzipWith(array, iteratee) {\n if (!(array && array.length)) {\n return [];\n }\n var result = unzip(array);\n if (iteratee == null) {\n return result;\n }\n return arrayMap(result, function(group) {\n return apply(iteratee, undefined, group);\n });\n }\n\n /**\n * Creates an array excluding all given values using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * **Note:** Unlike `_.pull`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...*} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.difference, _.xor\n * @example\n *\n * _.without([2, 1, 2, 3], 1, 2);\n * // => [3]\n */\n var without = baseRest(function(array, values) {\n return isArrayLikeObject(array)\n ? baseDifference(array, values)\n : [];\n });\n\n /**\n * Creates an array of unique values that is the\n * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n * of the given arrays. The order of result values is determined by the order\n * they occur in the arrays.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.difference, _.without\n * @example\n *\n * _.xor([2, 1], [2, 3]);\n * // => [1, 3]\n */\n var xor = baseRest(function(arrays) {\n return baseXor(arrayFilter(arrays, isArrayLikeObject));\n });\n\n /**\n * This method is like `_.xor` except that it accepts `iteratee` which is\n * invoked for each element of each `arrays` to generate the criterion by\n * which by which they're compared. The order of result values is determined\n * by the order they occur in the arrays. The iteratee is invoked with one\n * argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [1.2, 3.4]\n *\n * // The `_.property` iteratee shorthand.\n * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 2 }]\n */\n var xorBy = baseRest(function(arrays) {\n var iteratee = last(arrays);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n });\n\n /**\n * This method is like `_.xor` except that it accepts `comparator` which is\n * invoked to compare elements of `arrays`. The order of result values is\n * determined by the order they occur in the arrays. The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.xorWith(objects, others, _.isEqual);\n * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n */\n var xorWith = baseRest(function(arrays) {\n var comparator = last(arrays);\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n });\n\n /**\n * Creates an array of grouped elements, the first of which contains the\n * first elements of the given arrays, the second of which contains the\n * second elements of the given arrays, and so on.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to process.\n * @returns {Array} Returns the new array of grouped elements.\n * @example\n *\n * _.zip(['a', 'b'], [1, 2], [true, false]);\n * // => [['a', 1, true], ['b', 2, false]]\n */\n var zip = baseRest(unzip);\n\n /**\n * This method is like `_.fromPairs` except that it accepts two arrays,\n * one of property identifiers and one of corresponding values.\n *\n * @static\n * @memberOf _\n * @since 0.4.0\n * @category Array\n * @param {Array} [props=[]] The property identifiers.\n * @param {Array} [values=[]] The property values.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.zipObject(['a', 'b'], [1, 2]);\n * // => { 'a': 1, 'b': 2 }\n */\n function zipObject(props, values) {\n return baseZipObject(props || [], values || [], assignValue);\n }\n\n /**\n * This method is like `_.zipObject` except that it supports property paths.\n *\n * @static\n * @memberOf _\n * @since 4.1.0\n * @category Array\n * @param {Array} [props=[]] The property identifiers.\n * @param {Array} [values=[]] The property values.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n */\n function zipObjectDeep(props, values) {\n return baseZipObject(props || [], values || [], baseSet);\n }\n\n /**\n * This method is like `_.zip` except that it accepts `iteratee` to specify\n * how grouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Array\n * @param {...Array} [arrays] The arrays to process.\n * @param {Function} [iteratee=_.identity] The function to combine\n * grouped values.\n * @returns {Array} Returns the new array of grouped elements.\n * @example\n *\n * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n * return a + b + c;\n * });\n * // => [111, 222]\n */\n var zipWith = baseRest(function(arrays) {\n var length = arrays.length,\n iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n return unzipWith(arrays, iteratee);\n });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n * chain sequences enabled. The result of such sequences must be unwrapped\n * with `_#value`.\n *\n * @static\n * @memberOf _\n * @since 1.3.0\n * @category Seq\n * @param {*} value The value to wrap.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 40 },\n * { 'user': 'pebbles', 'age': 1 }\n * ];\n *\n * var youngest = _\n * .chain(users)\n * .sortBy('age')\n * .map(function(o) {\n * return o.user + ' is ' + o.age;\n * })\n * .head()\n * .value();\n * // => 'pebbles is 1'\n */\n function chain(value) {\n var result = lodash(value);\n result.__chain__ = true;\n return result;\n }\n\n /**\n * This method invokes `interceptor` and returns `value`. The interceptor\n * is invoked with one argument; (value). The purpose of this method is to\n * \"tap into\" a method chain sequence in order to modify intermediate results.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @param {*} value The value to provide to `interceptor`.\n * @param {Function} interceptor The function to invoke.\n * @returns {*} Returns `value`.\n * @example\n *\n * _([1, 2, 3])\n * .tap(function(array) {\n * // Mutate input array.\n * array.pop();\n * })\n * .reverse()\n * .value();\n * // => [2, 1]\n */\n function tap(value, interceptor) {\n interceptor(value);\n return value;\n }\n\n /**\n * This method is like `_.tap` except that it returns the result of `interceptor`.\n * The purpose of this method is to \"pass thru\" values replacing intermediate\n * results in a method chain sequence.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Seq\n * @param {*} value The value to provide to `interceptor`.\n * @param {Function} interceptor The function to invoke.\n * @returns {*} Returns the result of `interceptor`.\n * @example\n *\n * _(' abc ')\n * .chain()\n * .trim()\n * .thru(function(value) {\n * return [value];\n * })\n * .value();\n * // => ['abc']\n */\n function thru(value, interceptor) {\n return interceptor(value);\n }\n\n /**\n * This method is the wrapper version of `_.at`.\n *\n * @name at\n * @memberOf _\n * @since 1.0.0\n * @category Seq\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n *\n * _(object).at(['a[0].b.c', 'a[1]']).value();\n * // => [3, 4]\n */\n var wrapperAt = flatRest(function(paths) {\n var length = paths.length,\n start = length ? paths[0] : 0,\n value = this.__wrapped__,\n interceptor = function(object) { return baseAt(object, paths); };\n\n if (length > 1 || this.__actions__.length ||\n !(value instanceof LazyWrapper) || !isIndex(start)) {\n return this.thru(interceptor);\n }\n value = value.slice(start, +start + (length ? 1 : 0));\n value.__actions__.push({\n 'func': thru,\n 'args': [interceptor],\n 'thisArg': undefined\n });\n return new LodashWrapper(value, this.__chain__).thru(function(array) {\n if (length && !array.length) {\n array.push(undefined);\n }\n return array;\n });\n });\n\n /**\n * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n *\n * @name chain\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 40 }\n * ];\n *\n * // A sequence without explicit chaining.\n * _(users).head();\n * // => { 'user': 'barney', 'age': 36 }\n *\n * // A sequence with explicit chaining.\n * _(users)\n * .chain()\n * .head()\n * .pick('user')\n * .value();\n * // => { 'user': 'barney' }\n */\n function wrapperChain() {\n return chain(this);\n }\n\n /**\n * Executes the chain sequence and returns the wrapped result.\n *\n * @name commit\n * @memberOf _\n * @since 3.2.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var array = [1, 2];\n * var wrapped = _(array).push(3);\n *\n * console.log(array);\n * // => [1, 2]\n *\n * wrapped = wrapped.commit();\n * console.log(array);\n * // => [1, 2, 3]\n *\n * wrapped.last();\n * // => 3\n *\n * console.log(array);\n * // => [1, 2, 3]\n */\n function wrapperCommit() {\n return new LodashWrapper(this.value(), this.__chain__);\n }\n\n /**\n * Gets the next value on a wrapped object following the\n * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n *\n * @name next\n * @memberOf _\n * @since 4.0.0\n * @category Seq\n * @returns {Object} Returns the next iterator value.\n * @example\n *\n * var wrapped = _([1, 2]);\n *\n * wrapped.next();\n * // => { 'done': false, 'value': 1 }\n *\n * wrapped.next();\n * // => { 'done': false, 'value': 2 }\n *\n * wrapped.next();\n * // => { 'done': true, 'value': undefined }\n */\n function wrapperNext() {\n if (this.__values__ === undefined) {\n this.__values__ = toArray(this.value());\n }\n var done = this.__index__ >= this.__values__.length,\n value = done ? undefined : this.__values__[this.__index__++];\n\n return { 'done': done, 'value': value };\n }\n\n /**\n * Enables the wrapper to be iterable.\n *\n * @name Symbol.iterator\n * @memberOf _\n * @since 4.0.0\n * @category Seq\n * @returns {Object} Returns the wrapper object.\n * @example\n *\n * var wrapped = _([1, 2]);\n *\n * wrapped[Symbol.iterator]() === wrapped;\n * // => true\n *\n * Array.from(wrapped);\n * // => [1, 2]\n */\n function wrapperToIterator() {\n return this;\n }\n\n /**\n * Creates a clone of the chain sequence planting `value` as the wrapped value.\n *\n * @name plant\n * @memberOf _\n * @since 3.2.0\n * @category Seq\n * @param {*} value The value to plant.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var wrapped = _([1, 2]).map(square);\n * var other = wrapped.plant([3, 4]);\n *\n * other.value();\n * // => [9, 16]\n *\n * wrapped.value();\n * // => [1, 4]\n */\n function wrapperPlant(value) {\n var result,\n parent = this;\n\n while (parent instanceof baseLodash) {\n var clone = wrapperClone(parent);\n clone.__index__ = 0;\n clone.__values__ = undefined;\n if (result) {\n previous.__wrapped__ = clone;\n } else {\n result = clone;\n }\n var previous = clone;\n parent = parent.__wrapped__;\n }\n previous.__wrapped__ = value;\n return result;\n }\n\n /**\n * This method is the wrapper version of `_.reverse`.\n *\n * **Note:** This method mutates the wrapped array.\n *\n * @name reverse\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _(array).reverse().value()\n * // => [3, 2, 1]\n *\n * console.log(array);\n * // => [3, 2, 1]\n */\n function wrapperReverse() {\n var value = this.__wrapped__;\n if (value instanceof LazyWrapper) {\n var wrapped = value;\n if (this.__actions__.length) {\n wrapped = new LazyWrapper(this);\n }\n wrapped = wrapped.reverse();\n wrapped.__actions__.push({\n 'func': thru,\n 'args': [reverse],\n 'thisArg': undefined\n });\n return new LodashWrapper(wrapped, this.__chain__);\n }\n return this.thru(reverse);\n }\n\n /**\n * Executes the chain sequence to resolve the unwrapped value.\n *\n * @name value\n * @memberOf _\n * @since 0.1.0\n * @alias toJSON, valueOf\n * @category Seq\n * @returns {*} Returns the resolved unwrapped value.\n * @example\n *\n * _([1, 2, 3]).value();\n * // => [1, 2, 3]\n */\n function wrapperValue() {\n return baseWrapperValue(this.__wrapped__, this.__actions__);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The corresponding value of\n * each key is the number of times the key was returned by `iteratee`. The\n * iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.countBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': 1, '6': 2 }\n *\n * // The `_.property` iteratee shorthand.\n * _.countBy(['one', 'two', 'three'], 'length');\n * // => { '3': 2, '5': 1 }\n */\n var countBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n ++result[key];\n } else {\n baseAssignValue(result, key, 1);\n }\n });\n\n /**\n * Checks if `predicate` returns truthy for **all** elements of `collection`.\n * Iteration is stopped once `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * **Note:** This method returns `true` for\n * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n * elements of empty collections.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n * @example\n *\n * _.every([true, 1, null, 'yes'], Boolean);\n * // => false\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.every(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.every(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.every(users, 'active');\n * // => false\n */\n function every(collection, predicate, guard) {\n var func = isArray(collection) ? arrayEvery : baseEvery;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Iterates over elements of `collection`, returning an array of all elements\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * **Note:** Unlike `_.remove`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.reject\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * _.filter(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, { 'age': 36, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.filter(users, 'active');\n * // => objects for ['barney']\n *\n * // Combining several predicates using `_.overEvery` or `_.overSome`.\n * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n * // => objects for ['fred', 'barney']\n */\n function filter(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false },\n * { 'user': 'pebbles', 'age': 1, 'active': true }\n * ];\n *\n * _.find(users, function(o) { return o.age < 40; });\n * // => object for 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.find(users, { 'age': 1, 'active': true });\n * // => object for 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.find(users, ['active', false]);\n * // => object for 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.find(users, 'active');\n * // => object for 'barney'\n */\n var find = createFind(findIndex);\n\n /**\n * This method is like `_.find` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=collection.length-1] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * _.findLast([1, 2, 3, 4], function(n) {\n * return n % 2 == 1;\n * });\n * // => 3\n */\n var findLast = createFind(findLastIndex);\n\n /**\n * Creates a flattened array of values by running each element in `collection`\n * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n * with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [n, n];\n * }\n *\n * _.flatMap([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\n function flatMap(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), 1);\n }\n\n /**\n * This method is like `_.flatMap` except that it recursively flattens the\n * mapped results.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [[[n, n]]];\n * }\n *\n * _.flatMapDeep([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\n function flatMapDeep(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), INFINITY);\n }\n\n /**\n * This method is like `_.flatMap` except that it recursively flattens the\n * mapped results up to `depth` times.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {number} [depth=1] The maximum recursion depth.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [[[n, n]]];\n * }\n *\n * _.flatMapDepth([1, 2], duplicate, 2);\n * // => [[1, 1], [2, 2]]\n */\n function flatMapDepth(collection, iteratee, depth) {\n depth = depth === undefined ? 1 : toInteger(depth);\n return baseFlatten(map(collection, iteratee), depth);\n }\n\n /**\n * Iterates over elements of `collection` and invokes `iteratee` for each element.\n * The iteratee is invoked with three arguments: (value, index|key, collection).\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n * property are iterated like arrays. To avoid this behavior use `_.forIn`\n * or `_.forOwn` for object iteration.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias each\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n * @see _.forEachRight\n * @example\n *\n * _.forEach([1, 2], function(value) {\n * console.log(value);\n * });\n * // => Logs `1` then `2`.\n *\n * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n */\n function forEach(collection, iteratee) {\n var func = isArray(collection) ? arrayEach : baseEach;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.forEach` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @alias eachRight\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n * @see _.forEach\n * @example\n *\n * _.forEachRight([1, 2], function(value) {\n * console.log(value);\n * });\n * // => Logs `2` then `1`.\n */\n function forEachRight(collection, iteratee) {\n var func = isArray(collection) ? arrayEachRight : baseEachRight;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n *\n * // The `_.property` iteratee shorthand.\n * _.groupBy(['one', 'two', 'three'], 'length');\n * // => { '3': ['one', 'two'], '5': ['three'] }\n */\n var groupBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n result[key].push(value);\n } else {\n baseAssignValue(result, key, [value]);\n }\n });\n\n /**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\n function includes(collection, value, fromIndex, guard) {\n collection = isArrayLike(collection) ? collection : values(collection);\n fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n var length = collection.length;\n if (fromIndex < 0) {\n fromIndex = nativeMax(length + fromIndex, 0);\n }\n return isString(collection)\n ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n }\n\n /**\n * Invokes the method at `path` of each element in `collection`, returning\n * an array of the results of each invoked method. Any additional arguments\n * are provided to each invoked method. If `path` is a function, it's invoked\n * for, and `this` bound to, each element in `collection`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Array|Function|string} path The path of the method to invoke or\n * the function invoked per iteration.\n * @param {...*} [args] The arguments to invoke each method with.\n * @returns {Array} Returns the array of results.\n * @example\n *\n * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n * // => [[1, 5, 7], [1, 2, 3]]\n *\n * _.invokeMap([123, 456], String.prototype.split, '');\n * // => [['1', '2', '3'], ['4', '5', '6']]\n */\n var invokeMap = baseRest(function(collection, path, args) {\n var index = -1,\n isFunc = typeof path == 'function',\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value) {\n result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n });\n return result;\n });\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The corresponding value of\n * each key is the last element responsible for generating the key. The\n * iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * var array = [\n * { 'dir': 'left', 'code': 97 },\n * { 'dir': 'right', 'code': 100 }\n * ];\n *\n * _.keyBy(array, function(o) {\n * return String.fromCharCode(o.code);\n * });\n * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n *\n * _.keyBy(array, 'dir');\n * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n */\n var keyBy = createAggregator(function(result, value, key) {\n baseAssignValue(result, key, value);\n });\n\n /**\n * Creates an array of values by running each element in `collection` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * _.map([4, 8], square);\n * // => [16, 64]\n *\n * _.map({ 'a': 4, 'b': 8 }, square);\n * // => [16, 64] (iteration order is not guaranteed)\n *\n * var users = [\n * { 'user': 'barney' },\n * { 'user': 'fred' }\n * ];\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\n function map(collection, iteratee) {\n var func = isArray(collection) ? arrayMap : baseMap;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.sortBy` except that it allows specifying the sort\n * orders of the iteratees to sort by. If `orders` is unspecified, all values\n * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n * descending or \"asc\" for ascending sort order of corresponding values.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n * The iteratees to sort by.\n * @param {string[]} [orders] The sort orders of `iteratees`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n * { 'user': 'fred', 'age': 48 },\n * { 'user': 'barney', 'age': 34 },\n * { 'user': 'fred', 'age': 40 },\n * { 'user': 'barney', 'age': 36 }\n * ];\n *\n * // Sort by `user` in ascending order and by `age` in descending order.\n * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n */\n function orderBy(collection, iteratees, orders, guard) {\n if (collection == null) {\n return [];\n }\n if (!isArray(iteratees)) {\n iteratees = iteratees == null ? [] : [iteratees];\n }\n orders = guard ? undefined : orders;\n if (!isArray(orders)) {\n orders = orders == null ? [] : [orders];\n }\n return baseOrderBy(collection, iteratees, orders);\n }\n\n /**\n * Creates an array of elements split into two groups, the first of which\n * contains elements `predicate` returns truthy for, the second of which\n * contains elements `predicate` returns falsey for. The predicate is\n * invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the array of grouped elements.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': true },\n * { 'user': 'pebbles', 'age': 1, 'active': false }\n * ];\n *\n * _.partition(users, function(o) { return o.active; });\n * // => objects for [['fred'], ['barney', 'pebbles']]\n *\n * // The `_.matches` iteratee shorthand.\n * _.partition(users, { 'age': 1, 'active': false });\n * // => objects for [['pebbles'], ['barney', 'fred']]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.partition(users, ['active', false]);\n * // => objects for [['barney', 'pebbles'], ['fred']]\n *\n * // The `_.property` iteratee shorthand.\n * _.partition(users, 'active');\n * // => objects for [['fred'], ['barney', 'pebbles']]\n */\n var partition = createAggregator(function(result, value, key) {\n result[key ? 0 : 1].push(value);\n }, function() { return [[], []]; });\n\n /**\n * Reduces `collection` to a value which is the accumulated result of running\n * each element in `collection` thru `iteratee`, where each successive\n * invocation is supplied the return value of the previous. If `accumulator`\n * is not given, the first element of `collection` is used as the initial\n * value. The iteratee is invoked with four arguments:\n * (accumulator, value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.reduce`, `_.reduceRight`, and `_.transform`.\n *\n * The guarded methods are:\n * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n * and `sortBy`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @returns {*} Returns the accumulated value.\n * @see _.reduceRight\n * @example\n *\n * _.reduce([1, 2], function(sum, n) {\n * return sum + n;\n * }, 0);\n * // => 3\n *\n * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n * (result[value] || (result[value] = [])).push(key);\n * return result;\n * }, {});\n * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n */\n function reduce(collection, iteratee, accumulator) {\n var func = isArray(collection) ? arrayReduce : baseReduce,\n initAccum = arguments.length < 3;\n\n return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n }\n\n /**\n * This method is like `_.reduce` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @returns {*} Returns the accumulated value.\n * @see _.reduce\n * @example\n *\n * var array = [[0, 1], [2, 3], [4, 5]];\n *\n * _.reduceRight(array, function(flattened, other) {\n * return flattened.concat(other);\n * }, []);\n * // => [4, 5, 2, 3, 0, 1]\n */\n function reduceRight(collection, iteratee, accumulator) {\n var func = isArray(collection) ? arrayReduceRight : baseReduce,\n initAccum = arguments.length < 3;\n\n return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n }\n\n /**\n * The opposite of `_.filter`; this method returns the elements of `collection`\n * that `predicate` does **not** return truthy for.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.filter\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': true }\n * ];\n *\n * _.reject(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.reject(users, { 'age': 40, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.reject(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.reject(users, 'active');\n * // => objects for ['barney']\n */\n function reject(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, negate(getIteratee(predicate, 3)));\n }\n\n /**\n * Gets a random element from `collection`.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to sample.\n * @returns {*} Returns the random element.\n * @example\n *\n * _.sample([1, 2, 3, 4]);\n * // => 2\n */\n function sample(collection) {\n var func = isArray(collection) ? arraySample : baseSample;\n return func(collection);\n }\n\n /**\n * Gets `n` random elements at unique keys from `collection` up to the\n * size of `collection`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to sample.\n * @param {number} [n=1] The number of elements to sample.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the random elements.\n * @example\n *\n * _.sampleSize([1, 2, 3], 2);\n * // => [3, 1]\n *\n * _.sampleSize([1, 2, 3], 4);\n * // => [2, 3, 1]\n */\n function sampleSize(collection, n, guard) {\n if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n n = 1;\n } else {\n n = toInteger(n);\n }\n var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n return func(collection, n);\n }\n\n /**\n * Creates an array of shuffled values, using a version of the\n * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to shuffle.\n * @returns {Array} Returns the new shuffled array.\n * @example\n *\n * _.shuffle([1, 2, 3, 4]);\n * // => [4, 1, 3, 2]\n */\n function shuffle(collection) {\n var func = isArray(collection) ? arrayShuffle : baseShuffle;\n return func(collection);\n }\n\n /**\n * Gets the size of `collection` by returning its length for array-like\n * values or the number of own enumerable string keyed properties for objects.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @returns {number} Returns the collection size.\n * @example\n *\n * _.size([1, 2, 3]);\n * // => 3\n *\n * _.size({ 'a': 1, 'b': 2 });\n * // => 2\n *\n * _.size('pebbles');\n * // => 7\n */\n function size(collection) {\n if (collection == null) {\n return 0;\n }\n if (isArrayLike(collection)) {\n return isString(collection) ? stringSize(collection) : collection.length;\n }\n var tag = getTag(collection);\n if (tag == mapTag || tag == setTag) {\n return collection.size;\n }\n return baseKeys(collection).length;\n }\n\n /**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * Iteration is stopped once `predicate` returns truthy. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.some(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.some(users, 'active');\n * // => true\n */\n function some(collection, predicate, guard) {\n var func = isArray(collection) ? arraySome : baseSome;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Creates an array of elements, sorted in ascending order by the results of\n * running each element in a collection thru each iteratee. This method\n * performs a stable sort, that is, it preserves the original sort order of\n * equal elements. The iteratees are invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n * The iteratees to sort by.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n * { 'user': 'fred', 'age': 48 },\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 30 },\n * { 'user': 'barney', 'age': 34 }\n * ];\n *\n * _.sortBy(users, [function(o) { return o.user; }]);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]\n *\n * _.sortBy(users, ['user', 'age']);\n * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]\n */\n var sortBy = baseRest(function(collection, iteratees) {\n if (collection == null) {\n return [];\n }\n var length = iteratees.length;\n if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n iteratees = [];\n } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n iteratees = [iteratees[0]];\n }\n return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\n var now = ctxNow || function() {\n return root.Date.now();\n };\n\n /*------------------------------------------------------------------------*/\n\n /**\n * The opposite of `_.before`; this method creates a function that invokes\n * `func` once it's called `n` or more times.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {number} n The number of calls before `func` is invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var saves = ['profile', 'settings'];\n *\n * var done = _.after(saves.length, function() {\n * console.log('done saving!');\n * });\n *\n * _.forEach(saves, function(type) {\n * asyncSave({ 'type': type, 'complete': done });\n * });\n * // => Logs 'done saving!' after the two async saves have completed.\n */\n function after(n, func) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n < 1) {\n return func.apply(this, arguments);\n }\n };\n }\n\n /**\n * Creates a function that invokes `func`, with up to `n` arguments,\n * ignoring any additional arguments.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to cap arguments for.\n * @param {number} [n=func.length] The arity cap.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new capped function.\n * @example\n *\n * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n * // => [6, 8, 10]\n */\n function ary(func, n, guard) {\n n = guard ? undefined : n;\n n = (func && n == null) ? func.length : n;\n return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n }\n\n /**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\n function before(n, func) {\n var result;\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n > 0) {\n result = func.apply(this, arguments);\n }\n if (n <= 1) {\n func = undefined;\n }\n return result;\n };\n }\n\n /**\n * Creates a function that invokes `func` with the `this` binding of `thisArg`\n * and `partials` prepended to the arguments it receives.\n *\n * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n * may be used as a placeholder for partially applied arguments.\n *\n * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n * property of bound functions.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to bind.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new bound function.\n * @example\n *\n * function greet(greeting, punctuation) {\n * return greeting + ' ' + this.user + punctuation;\n * }\n *\n * var object = { 'user': 'fred' };\n *\n * var bound = _.bind(greet, object, 'hi');\n * bound('!');\n * // => 'hi fred!'\n *\n * // Bound with placeholders.\n * var bound = _.bind(greet, object, _, '!');\n * bound('hi');\n * // => 'hi fred!'\n */\n var bind = baseRest(function(func, thisArg, partials) {\n var bitmask = WRAP_BIND_FLAG;\n if (partials.length) {\n var holders = replaceHolders(partials, getHolder(bind));\n bitmask |= WRAP_PARTIAL_FLAG;\n }\n return createWrap(func, bitmask, thisArg, partials, holders);\n });\n\n /**\n * Creates a function that invokes the method at `object[key]` with `partials`\n * prepended to the arguments it receives.\n *\n * This method differs from `_.bind` by allowing bound functions to reference\n * methods that may be redefined or don't yet exist. See\n * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n * for more details.\n *\n * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Function\n * @param {Object} object The object to invoke the method on.\n * @param {string} key The key of the method.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new bound function.\n * @example\n *\n * var object = {\n * 'user': 'fred',\n * 'greet': function(greeting, punctuation) {\n * return greeting + ' ' + this.user + punctuation;\n * }\n * };\n *\n * var bound = _.bindKey(object, 'greet', 'hi');\n * bound('!');\n * // => 'hi fred!'\n *\n * object.greet = function(greeting, punctuation) {\n * return greeting + 'ya ' + this.user + punctuation;\n * };\n *\n * bound('!');\n * // => 'hiya fred!'\n *\n * // Bound with placeholders.\n * var bound = _.bindKey(object, 'greet', _, '!');\n * bound('hi');\n * // => 'hiya fred!'\n */\n var bindKey = baseRest(function(object, key, partials) {\n var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n if (partials.length) {\n var holders = replaceHolders(partials, getHolder(bindKey));\n bitmask |= WRAP_PARTIAL_FLAG;\n }\n return createWrap(key, bitmask, object, partials, holders);\n });\n\n /**\n * Creates a function that accepts arguments of `func` and either invokes\n * `func` returning its result, if at least `arity` number of arguments have\n * been provided, or returns a function that accepts the remaining `func`\n * arguments, and so on. The arity of `func` may be specified if `func.length`\n * is not sufficient.\n *\n * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n * may be used as a placeholder for provided arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of curried functions.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Function\n * @param {Function} func The function to curry.\n * @param {number} [arity=func.length] The arity of `func`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new curried function.\n * @example\n *\n * var abc = function(a, b, c) {\n * return [a, b, c];\n * };\n *\n * var curried = _.curry(abc);\n *\n * curried(1)(2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2, 3);\n * // => [1, 2, 3]\n *\n * // Curried with placeholders.\n * curried(1)(_, 3)(2);\n * // => [1, 2, 3]\n */\n function curry(func, arity, guard) {\n arity = guard ? undefined : arity;\n var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n result.placeholder = curry.placeholder;\n return result;\n }\n\n /**\n * This method is like `_.curry` except that arguments are applied to `func`\n * in the manner of `_.partialRight` instead of `_.partial`.\n *\n * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for provided arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of curried functions.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to curry.\n * @param {number} [arity=func.length] The arity of `func`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new curried function.\n * @example\n *\n * var abc = function(a, b, c) {\n * return [a, b, c];\n * };\n *\n * var curried = _.curryRight(abc);\n *\n * curried(3)(2)(1);\n * // => [1, 2, 3]\n *\n * curried(2, 3)(1);\n * // => [1, 2, 3]\n *\n * curried(1, 2, 3);\n * // => [1, 2, 3]\n *\n * // Curried with placeholders.\n * curried(3)(1, _)(2);\n * // => [1, 2, 3]\n */\n function curryRight(func, arity, guard) {\n arity = guard ? undefined : arity;\n var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n result.placeholder = curryRight.placeholder;\n return result;\n }\n\n /**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\n function debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n clearTimeout(timerId);\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n }\n\n /**\n * Defers invoking the `func` until the current call stack has cleared. Any\n * additional arguments are provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to defer.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.defer(function(text) {\n * console.log(text);\n * }, 'deferred');\n * // => Logs 'deferred' after one millisecond.\n */\n var defer = baseRest(function(func, args) {\n return baseDelay(func, 1, args);\n });\n\n /**\n * Invokes `func` after `wait` milliseconds. Any additional arguments are\n * provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.delay(function(text) {\n * console.log(text);\n * }, 1000, 'later');\n * // => Logs 'later' after one second.\n */\n var delay = baseRest(function(func, wait, args) {\n return baseDelay(func, toNumber(wait) || 0, args);\n });\n\n /**\n * Creates a function that invokes `func` with arguments reversed.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to flip arguments for.\n * @returns {Function} Returns the new flipped function.\n * @example\n *\n * var flipped = _.flip(function() {\n * return _.toArray(arguments);\n * });\n *\n * flipped('a', 'b', 'c', 'd');\n * // => ['d', 'c', 'b', 'a']\n */\n function flip(func) {\n return createWrap(func, WRAP_FLIP_FLAG);\n }\n\n /**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\n function memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n }\n\n // Expose `MapCache`.\n memoize.Cache = MapCache;\n\n /**\n * Creates a function that negates the result of the predicate `func`. The\n * `func` predicate is invoked with the `this` binding and arguments of the\n * created function.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} predicate The predicate to negate.\n * @returns {Function} Returns the new negated function.\n * @example\n *\n * function isEven(n) {\n * return n % 2 == 0;\n * }\n *\n * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n * // => [1, 3, 5]\n */\n function negate(predicate) {\n if (typeof predicate != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return function() {\n var args = arguments;\n switch (args.length) {\n case 0: return !predicate.call(this);\n case 1: return !predicate.call(this, args[0]);\n case 2: return !predicate.call(this, args[0], args[1]);\n case 3: return !predicate.call(this, args[0], args[1], args[2]);\n }\n return !predicate.apply(this, args);\n };\n }\n\n /**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\n function once(func) {\n return before(2, func);\n }\n\n /**\n * Creates a function that invokes `func` with its arguments transformed.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Function\n * @param {Function} func The function to wrap.\n * @param {...(Function|Function[])} [transforms=[_.identity]]\n * The argument transforms.\n * @returns {Function} Returns the new function.\n * @example\n *\n * function doubled(n) {\n * return n * 2;\n * }\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var func = _.overArgs(function(x, y) {\n * return [x, y];\n * }, [square, doubled]);\n *\n * func(9, 3);\n * // => [81, 6]\n *\n * func(10, 5);\n * // => [100, 10]\n */\n var overArgs = castRest(function(func, transforms) {\n transforms = (transforms.length == 1 && isArray(transforms[0]))\n ? arrayMap(transforms[0], baseUnary(getIteratee()))\n : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n var funcsLength = transforms.length;\n return baseRest(function(args) {\n var index = -1,\n length = nativeMin(args.length, funcsLength);\n\n while (++index < length) {\n args[index] = transforms[index].call(this, args[index]);\n }\n return apply(func, this, args);\n });\n });\n\n /**\n * Creates a function that invokes `func` with `partials` prepended to the\n * arguments it receives. This method is like `_.bind` except it does **not**\n * alter the `this` binding.\n *\n * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of partially\n * applied functions.\n *\n * @static\n * @memberOf _\n * @since 0.2.0\n * @category Function\n * @param {Function} func The function to partially apply arguments to.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new partially applied function.\n * @example\n *\n * function greet(greeting, name) {\n * return greeting + ' ' + name;\n * }\n *\n * var sayHelloTo = _.partial(greet, 'hello');\n * sayHelloTo('fred');\n * // => 'hello fred'\n *\n * // Partially applied with placeholders.\n * var greetFred = _.partial(greet, _, 'fred');\n * greetFred('hi');\n * // => 'hi fred'\n */\n var partial = baseRest(function(func, partials) {\n var holders = replaceHolders(partials, getHolder(partial));\n return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n });\n\n /**\n * This method is like `_.partial` except that partially applied arguments\n * are appended to the arguments it receives.\n *\n * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of partially\n * applied functions.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Function\n * @param {Function} func The function to partially apply arguments to.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new partially applied function.\n * @example\n *\n * function greet(greeting, name) {\n * return greeting + ' ' + name;\n * }\n *\n * var greetFred = _.partialRight(greet, 'fred');\n * greetFred('hi');\n * // => 'hi fred'\n *\n * // Partially applied with placeholders.\n * var sayHelloTo = _.partialRight(greet, 'hello', _);\n * sayHelloTo('fred');\n * // => 'hello fred'\n */\n var partialRight = baseRest(function(func, partials) {\n var holders = replaceHolders(partials, getHolder(partialRight));\n return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n });\n\n /**\n * Creates a function that invokes `func` with arguments arranged according\n * to the specified `indexes` where the argument value at the first index is\n * provided as the first argument, the argument value at the second index is\n * provided as the second argument, and so on.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to rearrange arguments for.\n * @param {...(number|number[])} indexes The arranged argument indexes.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var rearged = _.rearg(function(a, b, c) {\n * return [a, b, c];\n * }, [2, 0, 1]);\n *\n * rearged('b', 'c', 'a')\n * // => ['a', 'b', 'c']\n */\n var rearg = flatRest(function(func, indexes) {\n return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n });\n\n /**\n * Creates a function that invokes `func` with the `this` binding of the\n * created function and arguments from `start` and beyond provided as\n * an array.\n *\n * **Note:** This method is based on the\n * [rest parameter](https://mdn.io/rest_parameters).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.rest(function(what, names) {\n * return what + ' ' + _.initial(names).join(', ') +\n * (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n * });\n *\n * say('hello', 'fred', 'barney', 'pebbles');\n * // => 'hello fred, barney, & pebbles'\n */\n function rest(func, start) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n start = start === undefined ? start : toInteger(start);\n return baseRest(func, start);\n }\n\n /**\n * Creates a function that invokes `func` with the `this` binding of the\n * create function and an array of arguments much like\n * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n *\n * **Note:** This method is based on the\n * [spread operator](https://mdn.io/spread_operator).\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Function\n * @param {Function} func The function to spread arguments over.\n * @param {number} [start=0] The start position of the spread.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.spread(function(who, what) {\n * return who + ' says ' + what;\n * });\n *\n * say(['fred', 'hello']);\n * // => 'fred says hello'\n *\n * var numbers = Promise.all([\n * Promise.resolve(40),\n * Promise.resolve(36)\n * ]);\n *\n * numbers.then(_.spread(function(x, y) {\n * return x + y;\n * }));\n * // => a Promise of 76\n */\n function spread(func, start) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n start = start == null ? 0 : nativeMax(toInteger(start), 0);\n return baseRest(function(args) {\n var array = args[start],\n otherArgs = castSlice(args, 0, start);\n\n if (array) {\n arrayPush(otherArgs, array);\n }\n return apply(func, this, otherArgs);\n });\n }\n\n /**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n * Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\n function throttle(func, wait, options) {\n var leading = true,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n if (isObject(options)) {\n leading = 'leading' in options ? !!options.leading : leading;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n return debounce(func, wait, {\n 'leading': leading,\n 'maxWait': wait,\n 'trailing': trailing\n });\n }\n\n /**\n * Creates a function that accepts up to one argument, ignoring any\n * additional arguments.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n * @example\n *\n * _.map(['6', '8', '10'], _.unary(parseInt));\n * // => [6, 8, 10]\n */\n function unary(func) {\n return ary(func, 1);\n }\n\n /**\n * Creates a function that provides `value` to `wrapper` as its first\n * argument. Any additional arguments provided to the function are appended\n * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n * binding of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {*} value The value to wrap.\n * @param {Function} [wrapper=identity] The wrapper function.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var p = _.wrap(_.escape, function(func, text) {\n * return '<p>' + func(text) + '</p>';\n * });\n *\n * p('fred, barney, & pebbles');\n * // => '<p>fred, barney, & pebbles</p>'\n */\n function wrap(value, wrapper) {\n return partial(castFunction(wrapper), value);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Casts `value` as an array if it's not one.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Lang\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast array.\n * @example\n *\n * _.castArray(1);\n * // => [1]\n *\n * _.castArray({ 'a': 1 });\n * // => [{ 'a': 1 }]\n *\n * _.castArray('abc');\n * // => ['abc']\n *\n * _.castArray(null);\n * // => [null]\n *\n * _.castArray(undefined);\n * // => [undefined]\n *\n * _.castArray();\n * // => []\n *\n * var array = [1, 2, 3];\n * console.log(_.castArray(array) === array);\n * // => true\n */\n function castArray() {\n if (!arguments.length) {\n return [];\n }\n var value = arguments[0];\n return isArray(value) ? value : [value];\n }\n\n /**\n * Creates a shallow clone of `value`.\n *\n * **Note:** This method is loosely based on the\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n * arrays. The own enumerable properties of `arguments` objects are cloned\n * as plain objects. An empty object is returned for uncloneable values such\n * as error objects, functions, DOM nodes, and WeakMaps.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to clone.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeep\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var shallow = _.clone(objects);\n * console.log(shallow[0] === objects[0]);\n * // => true\n */\n function clone(value) {\n return baseClone(value, CLONE_SYMBOLS_FLAG);\n }\n\n /**\n * This method is like `_.clone` except that it accepts `customizer` which\n * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n * cloning is handled by the method instead. The `customizer` is invoked with\n * up to four arguments; (value [, index|key, object, stack]).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to clone.\n * @param {Function} [customizer] The function to customize cloning.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeepWith\n * @example\n *\n * function customizer(value) {\n * if (_.isElement(value)) {\n * return value.cloneNode(false);\n * }\n * }\n *\n * var el = _.cloneWith(document.body, customizer);\n *\n * console.log(el === document.body);\n * // => false\n * console.log(el.nodeName);\n * // => 'BODY'\n * console.log(el.childNodes.length);\n * // => 0\n */\n function cloneWith(value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n }\n\n /**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\n function cloneDeep(value) {\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n }\n\n /**\n * This method is like `_.cloneWith` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @param {Function} [customizer] The function to customize cloning.\n * @returns {*} Returns the deep cloned value.\n * @see _.cloneWith\n * @example\n *\n * function customizer(value) {\n * if (_.isElement(value)) {\n * return value.cloneNode(true);\n * }\n * }\n *\n * var el = _.cloneDeepWith(document.body, customizer);\n *\n * console.log(el === document.body);\n * // => false\n * console.log(el.nodeName);\n * // => 'BODY'\n * console.log(el.childNodes.length);\n * // => 20\n */\n function cloneDeepWith(value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n }\n\n /**\n * Checks if `object` conforms to `source` by invoking the predicate\n * properties of `source` with the corresponding property values of `object`.\n *\n * **Note:** This method is equivalent to `_.conforms` when `source` is\n * partially applied.\n *\n * @static\n * @memberOf _\n * @since 4.14.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property predicates to conform to.\n * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n *\n * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n * // => true\n *\n * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n * // => false\n */\n function conformsTo(object, source) {\n return source == null || baseConformsTo(object, source, keys(source));\n }\n\n /**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\n function eq(value, other) {\n return value === other || (value !== value && other !== other);\n }\n\n /**\n * Checks if `value` is greater than `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than `other`,\n * else `false`.\n * @see _.lt\n * @example\n *\n * _.gt(3, 1);\n * // => true\n *\n * _.gt(3, 3);\n * // => false\n *\n * _.gt(1, 3);\n * // => false\n */\n var gt = createRelationalOperation(baseGt);\n\n /**\n * Checks if `value` is greater than or equal to `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than or equal to\n * `other`, else `false`.\n * @see _.lte\n * @example\n *\n * _.gte(3, 1);\n * // => true\n *\n * _.gte(3, 3);\n * // => true\n *\n * _.gte(1, 3);\n * // => false\n */\n var gte = createRelationalOperation(function(value, other) {\n return value >= other;\n });\n\n /**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\n var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n };\n\n /**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\n var isArray = Array.isArray;\n\n /**\n * Checks if `value` is classified as an `ArrayBuffer` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n * @example\n *\n * _.isArrayBuffer(new ArrayBuffer(2));\n * // => true\n *\n * _.isArrayBuffer(new Array(2));\n * // => false\n */\n var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n /**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\n function isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n }\n\n /**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\n function isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n }\n\n /**\n * Checks if `value` is classified as a boolean primitive or object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n * @example\n *\n * _.isBoolean(false);\n * // => true\n *\n * _.isBoolean(null);\n * // => false\n */\n function isBoolean(value) {\n return value === true || value === false ||\n (isObjectLike(value) && baseGetTag(value) == boolTag);\n }\n\n /**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\n var isBuffer = nativeIsBuffer || stubFalse;\n\n /**\n * Checks if `value` is classified as a `Date` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n * @example\n *\n * _.isDate(new Date);\n * // => true\n *\n * _.isDate('Mon April 23 2012');\n * // => false\n */\n var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n /**\n * Checks if `value` is likely a DOM element.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n * @example\n *\n * _.isElement(document.body);\n * // => true\n *\n * _.isElement('<body>');\n * // => false\n */\n function isElement(value) {\n return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n }\n\n /**\n * Checks if `value` is an empty object, collection, map, or set.\n *\n * Objects are considered empty if they have no own enumerable string keyed\n * properties.\n *\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n * jQuery-like collections are considered empty if they have a `length` of `0`.\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n *\n * _.isEmpty(null);\n * // => true\n *\n * _.isEmpty(true);\n * // => true\n *\n * _.isEmpty(1);\n * // => true\n *\n * _.isEmpty([1, 2, 3]);\n * // => false\n *\n * _.isEmpty({ 'a': 1 });\n * // => false\n */\n function isEmpty(value) {\n if (value == null) {\n return true;\n }\n if (isArrayLike(value) &&\n (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n return !value.length;\n }\n var tag = getTag(value);\n if (tag == mapTag || tag == setTag) {\n return !value.size;\n }\n if (isPrototype(value)) {\n return !baseKeys(value).length;\n }\n for (var key in value) {\n if (hasOwnProperty.call(value, key)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\n function isEqual(value, other) {\n return baseIsEqual(value, other);\n }\n\n /**\n * This method is like `_.isEqual` except that it accepts `customizer` which\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n * are handled by the method instead. The `customizer` is invoked with up to\n * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * function isGreeting(value) {\n * return /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue, othValue) {\n * if (isGreeting(objValue) && isGreeting(othValue)) {\n * return true;\n * }\n * }\n *\n * var array = ['hello', 'goodbye'];\n * var other = ['hi', 'goodbye'];\n *\n * _.isEqualWith(array, other, customizer);\n * // => true\n */\n function isEqualWith(value, other, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n var result = customizer ? customizer(value, other) : undefined;\n return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n }\n\n /**\n * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n * `SyntaxError`, `TypeError`, or `URIError` object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n * @example\n *\n * _.isError(new Error);\n * // => true\n *\n * _.isError(Error);\n * // => false\n */\n function isError(value) {\n if (!isObjectLike(value)) {\n return false;\n }\n var tag = baseGetTag(value);\n return tag == errorTag || tag == domExcTag ||\n (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n }\n\n /**\n * Checks if `value` is a finite primitive number.\n *\n * **Note:** This method is based on\n * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n * @example\n *\n * _.isFinite(3);\n * // => true\n *\n * _.isFinite(Number.MIN_VALUE);\n * // => true\n *\n * _.isFinite(Infinity);\n * // => false\n *\n * _.isFinite('3');\n * // => false\n */\n function isFinite(value) {\n return typeof value == 'number' && nativeIsFinite(value);\n }\n\n /**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\n function isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n }\n\n /**\n * Checks if `value` is an integer.\n *\n * **Note:** This method is based on\n * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n * @example\n *\n * _.isInteger(3);\n * // => true\n *\n * _.isInteger(Number.MIN_VALUE);\n * // => false\n *\n * _.isInteger(Infinity);\n * // => false\n *\n * _.isInteger('3');\n * // => false\n */\n function isInteger(value) {\n return typeof value == 'number' && value == toInteger(value);\n }\n\n /**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\n function isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n }\n\n /**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\n function isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n }\n\n /**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\n function isObjectLike(value) {\n return value != null && typeof value == 'object';\n }\n\n /**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\n var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n /**\n * Performs a partial deep comparison between `object` and `source` to\n * determine if `object` contains equivalent property values.\n *\n * **Note:** This method is equivalent to `_.matches` when `source` is\n * partially applied.\n *\n * Partial comparisons will match empty array and empty object `source`\n * values against any array or object value, respectively. See `_.isEqual`\n * for a list of supported value comparisons.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n *\n * _.isMatch(object, { 'b': 2 });\n * // => true\n *\n * _.isMatch(object, { 'b': 1 });\n * // => false\n */\n function isMatch(object, source) {\n return object === source || baseIsMatch(object, source, getMatchData(source));\n }\n\n /**\n * This method is like `_.isMatch` except that it accepts `customizer` which\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n * are handled by the method instead. The `customizer` is invoked with five\n * arguments: (objValue, srcValue, index|key, object, source).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n * @example\n *\n * function isGreeting(value) {\n * return /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue, srcValue) {\n * if (isGreeting(objValue) && isGreeting(srcValue)) {\n * return true;\n * }\n * }\n *\n * var object = { 'greeting': 'hello' };\n * var source = { 'greeting': 'hi' };\n *\n * _.isMatchWith(object, source, customizer);\n * // => true\n */\n function isMatchWith(object, source, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseIsMatch(object, source, getMatchData(source), customizer);\n }\n\n /**\n * Checks if `value` is `NaN`.\n *\n * **Note:** This method is based on\n * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n * `undefined` and other non-number values.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n * @example\n *\n * _.isNaN(NaN);\n * // => true\n *\n * _.isNaN(new Number(NaN));\n * // => true\n *\n * isNaN(undefined);\n * // => true\n *\n * _.isNaN(undefined);\n * // => false\n */\n function isNaN(value) {\n // An `NaN` primitive is the only value that is not equal to itself.\n // Perform the `toStringTag` check first to avoid errors with some\n // ActiveX objects in IE.\n return isNumber(value) && value != +value;\n }\n\n /**\n * Checks if `value` is a pristine native function.\n *\n * **Note:** This method can't reliably detect native functions in the presence\n * of the core-js package because core-js circumvents this kind of detection.\n * Despite multiple requests, the core-js maintainer has made it clear: any\n * attempt to fix the detection will be obstructed. As a result, we're left\n * with little choice but to throw an error. Unfortunately, this also affects\n * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n * which rely on core-js.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n * @example\n *\n * _.isNative(Array.prototype.push);\n * // => true\n *\n * _.isNative(_);\n * // => false\n */\n function isNative(value) {\n if (isMaskable(value)) {\n throw new Error(CORE_ERROR_TEXT);\n }\n return baseIsNative(value);\n }\n\n /**\n * Checks if `value` is `null`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n * @example\n *\n * _.isNull(null);\n * // => true\n *\n * _.isNull(void 0);\n * // => false\n */\n function isNull(value) {\n return value === null;\n }\n\n /**\n * Checks if `value` is `null` or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n * @example\n *\n * _.isNil(null);\n * // => true\n *\n * _.isNil(void 0);\n * // => true\n *\n * _.isNil(NaN);\n * // => false\n */\n function isNil(value) {\n return value == null;\n }\n\n /**\n * Checks if `value` is classified as a `Number` primitive or object.\n *\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n * classified as numbers, use the `_.isFinite` method.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n * @example\n *\n * _.isNumber(3);\n * // => true\n *\n * _.isNumber(Number.MIN_VALUE);\n * // => true\n *\n * _.isNumber(Infinity);\n * // => true\n *\n * _.isNumber('3');\n * // => false\n */\n function isNumber(value) {\n return typeof value == 'number' ||\n (isObjectLike(value) && baseGetTag(value) == numberTag);\n }\n\n /**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\n function isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n }\n\n /**\n * Checks if `value` is classified as a `RegExp` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n * @example\n *\n * _.isRegExp(/abc/);\n * // => true\n *\n * _.isRegExp('/abc/');\n * // => false\n */\n var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n /**\n * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n * double precision number which isn't the result of a rounded unsafe integer.\n *\n * **Note:** This method is based on\n * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n * @example\n *\n * _.isSafeInteger(3);\n * // => true\n *\n * _.isSafeInteger(Number.MIN_VALUE);\n * // => false\n *\n * _.isSafeInteger(Infinity);\n * // => false\n *\n * _.isSafeInteger('3');\n * // => false\n */\n function isSafeInteger(value) {\n return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n }\n\n /**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\n var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n /**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\n function isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n }\n\n /**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\n function isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n }\n\n /**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\n var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n /**\n * Checks if `value` is `undefined`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n * @example\n *\n * _.isUndefined(void 0);\n * // => true\n *\n * _.isUndefined(null);\n * // => false\n */\n function isUndefined(value) {\n return value === undefined;\n }\n\n /**\n * Checks if `value` is classified as a `WeakMap` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n * @example\n *\n * _.isWeakMap(new WeakMap);\n * // => true\n *\n * _.isWeakMap(new Map);\n * // => false\n */\n function isWeakMap(value) {\n return isObjectLike(value) && getTag(value) == weakMapTag;\n }\n\n /**\n * Checks if `value` is classified as a `WeakSet` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n * @example\n *\n * _.isWeakSet(new WeakSet);\n * // => true\n *\n * _.isWeakSet(new Set);\n * // => false\n */\n function isWeakSet(value) {\n return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n }\n\n /**\n * Checks if `value` is less than `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n * else `false`.\n * @see _.gt\n * @example\n *\n * _.lt(1, 3);\n * // => true\n *\n * _.lt(3, 3);\n * // => false\n *\n * _.lt(3, 1);\n * // => false\n */\n var lt = createRelationalOperation(baseLt);\n\n /**\n * Checks if `value` is less than or equal to `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than or equal to\n * `other`, else `false`.\n * @see _.gte\n * @example\n *\n * _.lte(1, 3);\n * // => true\n *\n * _.lte(3, 3);\n * // => true\n *\n * _.lte(3, 1);\n * // => false\n */\n var lte = createRelationalOperation(function(value, other) {\n return value <= other;\n });\n\n /**\n * Converts `value` to an array.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Array} Returns the converted array.\n * @example\n *\n * _.toArray({ 'a': 1, 'b': 2 });\n * // => [1, 2]\n *\n * _.toArray('abc');\n * // => ['a', 'b', 'c']\n *\n * _.toArray(1);\n * // => []\n *\n * _.toArray(null);\n * // => []\n */\n function toArray(value) {\n if (!value) {\n return [];\n }\n if (isArrayLike(value)) {\n return isString(value) ? stringToArray(value) : copyArray(value);\n }\n if (symIterator && value[symIterator]) {\n return iteratorToArray(value[symIterator]());\n }\n var tag = getTag(value),\n func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n return func(value);\n }\n\n /**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\n function toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n }\n\n /**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\n function toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n }\n\n /**\n * Converts `value` to an integer suitable for use as the length of an\n * array-like object.\n *\n * **Note:** This method is based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toLength(3.2);\n * // => 3\n *\n * _.toLength(Number.MIN_VALUE);\n * // => 0\n *\n * _.toLength(Infinity);\n * // => 4294967295\n *\n * _.toLength('3.2');\n * // => 3\n */\n function toLength(value) {\n return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n }\n\n /**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\n function toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n }\n\n /**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\n function toPlainObject(value) {\n return copyObject(value, keysIn(value));\n }\n\n /**\n * Converts `value` to a safe integer. A safe integer can be compared and\n * represented correctly.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toSafeInteger(3.2);\n * // => 3\n *\n * _.toSafeInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toSafeInteger(Infinity);\n * // => 9007199254740991\n *\n * _.toSafeInteger('3.2');\n * // => 3\n */\n function toSafeInteger(value) {\n return value\n ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n : (value === 0 ? value : 0);\n }\n\n /**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\n function toString(value) {\n return value == null ? '' : baseToString(value);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * function Bar() {\n * this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assign({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3 }\n */\n var assign = createAssigner(function(object, source) {\n if (isPrototype(source) || isArrayLike(source)) {\n copyObject(source, keys(source), object);\n return;\n }\n for (var key in source) {\n if (hasOwnProperty.call(source, key)) {\n assignValue(object, key, source[key]);\n }\n }\n });\n\n /**\n * This method is like `_.assign` except that it iterates over own and\n * inherited source properties.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias extend\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assign\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * function Bar() {\n * this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n */\n var assignIn = createAssigner(function(object, source) {\n copyObject(source, keysIn(source), object);\n });\n\n /**\n * This method is like `_.assignIn` except that it accepts `customizer`\n * which is invoked to produce the assigned values. If `customizer` returns\n * `undefined`, assignment is handled by the method instead. The `customizer`\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias extendWith\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @see _.assignWith\n * @example\n *\n * function customizer(objValue, srcValue) {\n * return _.isUndefined(objValue) ? srcValue : objValue;\n * }\n *\n * var defaults = _.partialRight(_.assignInWith, customizer);\n *\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n copyObject(source, keysIn(source), object, customizer);\n });\n\n /**\n * This method is like `_.assign` except that it accepts `customizer`\n * which is invoked to produce the assigned values. If `customizer` returns\n * `undefined`, assignment is handled by the method instead. The `customizer`\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @see _.assignInWith\n * @example\n *\n * function customizer(objValue, srcValue) {\n * return _.isUndefined(objValue) ? srcValue : objValue;\n * }\n *\n * var defaults = _.partialRight(_.assignWith, customizer);\n *\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n copyObject(source, keys(source), object, customizer);\n });\n\n /**\n * Creates an array of values corresponding to `paths` of `object`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Array} Returns the picked values.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n *\n * _.at(object, ['a[0].b.c', 'a[1]']);\n * // => [3, 4]\n */\n var at = flatRest(baseAt);\n\n /**\n * Creates an object that inherits from the `prototype` object. If a\n * `properties` object is given, its own enumerable string keyed properties\n * are assigned to the created object.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Object\n * @param {Object} prototype The object to inherit from.\n * @param {Object} [properties] The properties to assign to the object.\n * @returns {Object} Returns the new object.\n * @example\n *\n * function Shape() {\n * this.x = 0;\n * this.y = 0;\n * }\n *\n * function Circle() {\n * Shape.call(this);\n * }\n *\n * Circle.prototype = _.create(Shape.prototype, {\n * 'constructor': Circle\n * });\n *\n * var circle = new Circle;\n * circle instanceof Circle;\n * // => true\n *\n * circle instanceof Shape;\n * // => true\n */\n function create(prototype, properties) {\n var result = baseCreate(prototype);\n return properties == null ? result : baseAssign(result, properties);\n }\n\n /**\n * Assigns own and inherited enumerable string keyed properties of source\n * objects to the destination object for all destination properties that\n * resolve to `undefined`. Source objects are applied from left to right.\n * Once a property is set, additional values of the same property are ignored.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaultsDeep\n * @example\n *\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var defaults = baseRest(function(object, sources) {\n object = Object(object);\n\n var index = -1;\n var length = sources.length;\n var guard = length > 2 ? sources[2] : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n length = 1;\n }\n\n while (++index < length) {\n var source = sources[index];\n var props = keysIn(source);\n var propsIndex = -1;\n var propsLength = props.length;\n\n while (++propsIndex < propsLength) {\n var key = props[propsIndex];\n var value = object[key];\n\n if (value === undefined ||\n (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n object[key] = source[key];\n }\n }\n }\n\n return object;\n });\n\n /**\n * This method is like `_.defaults` except that it recursively assigns\n * default properties.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaults\n * @example\n *\n * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n * // => { 'a': { 'b': 2, 'c': 3 } }\n */\n var defaultsDeep = baseRest(function(args) {\n args.push(undefined, customDefaultsMerge);\n return apply(mergeWith, undefined, args);\n });\n\n /**\n * This method is like `_.find` except that it returns the key of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {string|undefined} Returns the key of the matched element,\n * else `undefined`.\n * @example\n *\n * var users = {\n * 'barney': { 'age': 36, 'active': true },\n * 'fred': { 'age': 40, 'active': false },\n * 'pebbles': { 'age': 1, 'active': true }\n * };\n *\n * _.findKey(users, function(o) { return o.age < 40; });\n * // => 'barney' (iteration order is not guaranteed)\n *\n * // The `_.matches` iteratee shorthand.\n * _.findKey(users, { 'age': 1, 'active': true });\n * // => 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findKey(users, ['active', false]);\n * // => 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.findKey(users, 'active');\n * // => 'barney'\n */\n function findKey(object, predicate) {\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n }\n\n /**\n * This method is like `_.findKey` except that it iterates over elements of\n * a collection in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {string|undefined} Returns the key of the matched element,\n * else `undefined`.\n * @example\n *\n * var users = {\n * 'barney': { 'age': 36, 'active': true },\n * 'fred': { 'age': 40, 'active': false },\n * 'pebbles': { 'age': 1, 'active': true }\n * };\n *\n * _.findLastKey(users, function(o) { return o.age < 40; });\n * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.findLastKey(users, { 'age': 36, 'active': true });\n * // => 'barney'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findLastKey(users, ['active', false]);\n * // => 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.findLastKey(users, 'active');\n * // => 'pebbles'\n */\n function findLastKey(object, predicate) {\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n }\n\n /**\n * Iterates over own and inherited enumerable string keyed properties of an\n * object and invokes `iteratee` for each property. The iteratee is invoked\n * with three arguments: (value, key, object). Iteratee functions may exit\n * iteration early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 0.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forInRight\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forIn(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n */\n function forIn(object, iteratee) {\n return object == null\n ? object\n : baseFor(object, getIteratee(iteratee, 3), keysIn);\n }\n\n /**\n * This method is like `_.forIn` except that it iterates over properties of\n * `object` in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forIn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forInRight(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n */\n function forInRight(object, iteratee) {\n return object == null\n ? object\n : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n }\n\n /**\n * Iterates over own enumerable string keyed properties of an object and\n * invokes `iteratee` for each property. The iteratee is invoked with three\n * arguments: (value, key, object). Iteratee functions may exit iteration\n * early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 0.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forOwnRight\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forOwn(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n */\n function forOwn(object, iteratee) {\n return object && baseForOwn(object, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.forOwn` except that it iterates over properties of\n * `object` in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forOwn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forOwnRight(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n */\n function forOwnRight(object, iteratee) {\n return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n }\n\n /**\n * Creates an array of function property names from own enumerable properties\n * of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to inspect.\n * @returns {Array} Returns the function names.\n * @see _.functionsIn\n * @example\n *\n * function Foo() {\n * this.a = _.constant('a');\n * this.b = _.constant('b');\n * }\n *\n * Foo.prototype.c = _.constant('c');\n *\n * _.functions(new Foo);\n * // => ['a', 'b']\n */\n function functions(object) {\n return object == null ? [] : baseFunctions(object, keys(object));\n }\n\n /**\n * Creates an array of function property names from own and inherited\n * enumerable properties of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @returns {Array} Returns the function names.\n * @see _.functions\n * @example\n *\n * function Foo() {\n * this.a = _.constant('a');\n * this.b = _.constant('b');\n * }\n *\n * Foo.prototype.c = _.constant('c');\n *\n * _.functionsIn(new Foo);\n * // => ['a', 'b', 'c']\n */\n function functionsIn(object) {\n return object == null ? [] : baseFunctions(object, keysIn(object));\n }\n\n /**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\n function get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n }\n\n /**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\n function has(object, path) {\n return object != null && hasPath(object, path, baseHas);\n }\n\n /**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\n function hasIn(object, path) {\n return object != null && hasPath(object, path, baseHasIn);\n }\n\n /**\n * Creates an object composed of the inverted keys and values of `object`.\n * If `object` contains duplicate values, subsequent values overwrite\n * property assignments of previous values.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Object\n * @param {Object} object The object to invert.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invert(object);\n * // => { '1': 'c', '2': 'b' }\n */\n var invert = createInverter(function(result, value, key) {\n if (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\n result[value] = key;\n }, constant(identity));\n\n /**\n * This method is like `_.invert` except that the inverted object is generated\n * from the results of running each element of `object` thru `iteratee`. The\n * corresponding inverted value of each inverted key is an array of keys\n * responsible for generating the inverted value. The iteratee is invoked\n * with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.1.0\n * @category Object\n * @param {Object} object The object to invert.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invertBy(object);\n * // => { '1': ['a', 'c'], '2': ['b'] }\n *\n * _.invertBy(object, function(value) {\n * return 'group' + value;\n * });\n * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n */\n var invertBy = createInverter(function(result, value, key) {\n if (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\n if (hasOwnProperty.call(result, value)) {\n result[value].push(key);\n } else {\n result[value] = [key];\n }\n }, getIteratee);\n\n /**\n * Invokes the method at `path` of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the method to invoke.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {*} Returns the result of the invoked method.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n *\n * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n * // => [2, 3]\n */\n var invoke = baseRest(baseInvoke);\n\n /**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\n function keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n }\n\n /**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\n function keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n }\n\n /**\n * The opposite of `_.mapValues`; this method creates an object with the\n * same values as `object` and keys generated by running each own enumerable\n * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n * with three arguments: (value, key, object).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns the new mapped object.\n * @see _.mapValues\n * @example\n *\n * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n * return key + value;\n * });\n * // => { 'a1': 1, 'b2': 2 }\n */\n function mapKeys(object, iteratee) {\n var result = {};\n iteratee = getIteratee(iteratee, 3);\n\n baseForOwn(object, function(value, key, object) {\n baseAssignValue(result, iteratee(value, key, object), value);\n });\n return result;\n }\n\n /**\n * Creates an object with the same keys as `object` and values generated\n * by running each own enumerable string keyed property of `object` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, key, object).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns the new mapped object.\n * @see _.mapKeys\n * @example\n *\n * var users = {\n * 'fred': { 'user': 'fred', 'age': 40 },\n * 'pebbles': { 'user': 'pebbles', 'age': 1 }\n * };\n *\n * _.mapValues(users, function(o) { return o.age; });\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n *\n * // The `_.property` iteratee shorthand.\n * _.mapValues(users, 'age');\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n */\n function mapValues(object, iteratee) {\n var result = {};\n iteratee = getIteratee(iteratee, 3);\n\n baseForOwn(object, function(value, key, object) {\n baseAssignValue(result, key, iteratee(value, key, object));\n });\n return result;\n }\n\n /**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n * 'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n * 'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\n var merge = createAssigner(function(object, source, srcIndex) {\n baseMerge(object, source, srcIndex);\n });\n\n /**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n * if (_.isArray(objValue)) {\n * return objValue.concat(srcValue);\n * }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\n var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n baseMerge(object, source, srcIndex, customizer);\n });\n\n /**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable property paths of `object` that are not omitted.\n *\n * **Note:** This method is considerably slower than `_.pick`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\n var omit = flatRest(function(object, paths) {\n var result = {};\n if (object == null) {\n return result;\n }\n var isDeep = false;\n paths = arrayMap(paths, function(path) {\n path = castPath(path, object);\n isDeep || (isDeep = path.length > 1);\n return path;\n });\n copyObject(object, getAllKeysIn(object), result);\n if (isDeep) {\n result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n }\n var length = paths.length;\n while (length--) {\n baseUnset(result, paths[length]);\n }\n return result;\n });\n\n /**\n * The opposite of `_.pickBy`; this method creates an object composed of\n * the own and inherited enumerable string keyed properties of `object` that\n * `predicate` doesn't return truthy for. The predicate is invoked with two\n * arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omitBy(object, _.isNumber);\n * // => { 'b': '2' }\n */\n function omitBy(object, predicate) {\n return pickBy(object, negate(getIteratee(predicate)));\n }\n\n /**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\n var pick = flatRest(function(object, paths) {\n return object == null ? {} : basePick(object, paths);\n });\n\n /**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\n function pickBy(object, predicate) {\n if (object == null) {\n return {};\n }\n var props = arrayMap(getAllKeysIn(object), function(prop) {\n return [prop];\n });\n predicate = getIteratee(predicate);\n return basePickBy(object, props, function(value, path) {\n return predicate(value, path[0]);\n });\n }\n\n /**\n * This method is like `_.get` except that if the resolved value is a\n * function it's invoked with the `this` binding of its parent object and\n * its result is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to resolve.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n *\n * _.result(object, 'a[0].b.c1');\n * // => 3\n *\n * _.result(object, 'a[0].b.c2');\n * // => 4\n *\n * _.result(object, 'a[0].b.c3', 'default');\n * // => 'default'\n *\n * _.result(object, 'a[0].b.c3', _.constant('default'));\n * // => 'default'\n */\n function result(object, path, defaultValue) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length;\n\n // Ensure the loop is entered when path is empty.\n if (!length) {\n length = 1;\n object = undefined;\n }\n while (++index < length) {\n var value = object == null ? undefined : object[toKey(path[index])];\n if (value === undefined) {\n index = length;\n value = defaultValue;\n }\n object = isFunction(value) ? value.call(object) : value;\n }\n return object;\n }\n\n /**\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n * it's created. Arrays are created for missing index properties while objects\n * are created for all other missing properties. Use `_.setWith` to customize\n * `path` creation.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.set(object, 'a[0].b.c', 4);\n * console.log(object.a[0].b.c);\n * // => 4\n *\n * _.set(object, ['x', '0', 'y', 'z'], 5);\n * console.log(object.x[0].y.z);\n * // => 5\n */\n function set(object, path, value) {\n return object == null ? object : baseSet(object, path, value);\n }\n\n /**\n * This method is like `_.set` except that it accepts `customizer` which is\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\n * path creation is handled by the method instead. The `customizer` is invoked\n * with three arguments: (nsValue, key, nsObject).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {};\n *\n * _.setWith(object, '[0][1]', 'a', Object);\n * // => { '0': { '1': 'a' } }\n */\n function setWith(object, path, value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return object == null ? object : baseSet(object, path, value, customizer);\n }\n\n /**\n * Creates an array of own enumerable string keyed-value pairs for `object`\n * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n * entries are returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias entries\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the key-value pairs.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.toPairs(new Foo);\n * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n */\n var toPairs = createToPairs(keys);\n\n /**\n * Creates an array of own and inherited enumerable string keyed-value pairs\n * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n * or set, its entries are returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias entriesIn\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the key-value pairs.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.toPairsIn(new Foo);\n * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n */\n var toPairsIn = createToPairs(keysIn);\n\n /**\n * An alternative to `_.reduce`; this method transforms `object` to a new\n * `accumulator` object which is the result of running each of its own\n * enumerable string keyed properties thru `iteratee`, with each invocation\n * potentially mutating the `accumulator` object. If `accumulator` is not\n * provided, a new object with the same `[[Prototype]]` will be used. The\n * iteratee is invoked with four arguments: (accumulator, value, key, object).\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 1.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The custom accumulator value.\n * @returns {*} Returns the accumulated value.\n * @example\n *\n * _.transform([2, 3, 4], function(result, n) {\n * result.push(n *= n);\n * return n % 2 == 0;\n * }, []);\n * // => [4, 9]\n *\n * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n * (result[value] || (result[value] = [])).push(key);\n * }, {});\n * // => { '1': ['a', 'c'], '2': ['b'] }\n */\n function transform(object, iteratee, accumulator) {\n var isArr = isArray(object),\n isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n iteratee = getIteratee(iteratee, 4);\n if (accumulator == null) {\n var Ctor = object && object.constructor;\n if (isArrLike) {\n accumulator = isArr ? new Ctor : [];\n }\n else if (isObject(object)) {\n accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n }\n else {\n accumulator = {};\n }\n }\n (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n return iteratee(accumulator, value, index, object);\n });\n return accumulator;\n }\n\n /**\n * Removes the property at `path` of `object`.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n * _.unset(object, 'a[0].b.c');\n * // => true\n *\n * console.log(object);\n * // => { 'a': [{ 'b': {} }] };\n *\n * _.unset(object, ['a', '0', 'b', 'c']);\n * // => true\n *\n * console.log(object);\n * // => { 'a': [{ 'b': {} }] };\n */\n function unset(object, path) {\n return object == null ? true : baseUnset(object, path);\n }\n\n /**\n * This method is like `_.set` except that accepts `updater` to produce the\n * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n * is invoked with one argument: (value).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {Function} updater The function to produce the updated value.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n * console.log(object.a[0].b.c);\n * // => 9\n *\n * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n * console.log(object.x[0].y.z);\n * // => 0\n */\n function update(object, path, updater) {\n return object == null ? object : baseUpdate(object, path, castFunction(updater));\n }\n\n /**\n * This method is like `_.update` except that it accepts `customizer` which is\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\n * path creation is handled by the method instead. The `customizer` is invoked\n * with three arguments: (nsValue, key, nsObject).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {Function} updater The function to produce the updated value.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {};\n *\n * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n * // => { '0': { '1': 'a' } }\n */\n function updateWith(object, path, updater, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n }\n\n /**\n * Creates an array of the own enumerable string keyed property values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.values(new Foo);\n * // => [1, 2] (iteration order is not guaranteed)\n *\n * _.values('hi');\n * // => ['h', 'i']\n */\n function values(object) {\n return object == null ? [] : baseValues(object, keys(object));\n }\n\n /**\n * Creates an array of the own and inherited enumerable string keyed property\n * values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.valuesIn(new Foo);\n * // => [1, 2, 3] (iteration order is not guaranteed)\n */\n function valuesIn(object) {\n return object == null ? [] : baseValues(object, keysIn(object));\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Clamps `number` within the inclusive `lower` and `upper` bounds.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Number\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n * @example\n *\n * _.clamp(-10, -5, 5);\n * // => -5\n *\n * _.clamp(10, -5, 5);\n * // => 5\n */\n function clamp(number, lower, upper) {\n if (upper === undefined) {\n upper = lower;\n lower = undefined;\n }\n if (upper !== undefined) {\n upper = toNumber(upper);\n upper = upper === upper ? upper : 0;\n }\n if (lower !== undefined) {\n lower = toNumber(lower);\n lower = lower === lower ? lower : 0;\n }\n return baseClamp(toNumber(number), lower, upper);\n }\n\n /**\n * Checks if `n` is between `start` and up to, but not including, `end`. If\n * `end` is not specified, it's set to `start` with `start` then set to `0`.\n * If `start` is greater than `end` the params are swapped to support\n * negative ranges.\n *\n * @static\n * @memberOf _\n * @since 3.3.0\n * @category Number\n * @param {number} number The number to check.\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n * @see _.range, _.rangeRight\n * @example\n *\n * _.inRange(3, 2, 4);\n * // => true\n *\n * _.inRange(4, 8);\n * // => true\n *\n * _.inRange(4, 2);\n * // => false\n *\n * _.inRange(2, 2);\n * // => false\n *\n * _.inRange(1.2, 2);\n * // => true\n *\n * _.inRange(5.2, 4);\n * // => false\n *\n * _.inRange(-3, -2, -6);\n * // => true\n */\n function inRange(number, start, end) {\n start = toFinite(start);\n if (end === undefined) {\n end = start;\n start = 0;\n } else {\n end = toFinite(end);\n }\n number = toNumber(number);\n return baseInRange(number, start, end);\n }\n\n /**\n * Produces a random number between the inclusive `lower` and `upper` bounds.\n * If only one argument is provided a number between `0` and the given number\n * is returned. If `floating` is `true`, or either `lower` or `upper` are\n * floats, a floating-point number is returned instead of an integer.\n *\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\n * floating-point values which can produce unexpected results.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Number\n * @param {number} [lower=0] The lower bound.\n * @param {number} [upper=1] The upper bound.\n * @param {boolean} [floating] Specify returning a floating-point number.\n * @returns {number} Returns the random number.\n * @example\n *\n * _.random(0, 5);\n * // => an integer between 0 and 5\n *\n * _.random(5);\n * // => also an integer between 0 and 5\n *\n * _.random(5, true);\n * // => a floating-point number between 0 and 5\n *\n * _.random(1.2, 5.2);\n * // => a floating-point number between 1.2 and 5.2\n */\n function random(lower, upper, floating) {\n if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n upper = floating = undefined;\n }\n if (floating === undefined) {\n if (typeof upper == 'boolean') {\n floating = upper;\n upper = undefined;\n }\n else if (typeof lower == 'boolean') {\n floating = lower;\n lower = undefined;\n }\n }\n if (lower === undefined && upper === undefined) {\n lower = 0;\n upper = 1;\n }\n else {\n lower = toFinite(lower);\n if (upper === undefined) {\n upper = lower;\n lower = 0;\n } else {\n upper = toFinite(upper);\n }\n }\n if (lower > upper) {\n var temp = lower;\n lower = upper;\n upper = temp;\n }\n if (floating || lower % 1 || upper % 1) {\n var rand = nativeRandom();\n return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n }\n return baseRandom(lower, upper);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the camel cased string.\n * @example\n *\n * _.camelCase('Foo Bar');\n * // => 'fooBar'\n *\n * _.camelCase('--foo-bar--');\n * // => 'fooBar'\n *\n * _.camelCase('__FOO_BAR__');\n * // => 'fooBar'\n */\n var camelCase = createCompounder(function(result, word, index) {\n word = word.toLowerCase();\n return result + (index ? capitalize(word) : word);\n });\n\n /**\n * Converts the first character of `string` to upper case and the remaining\n * to lower case.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to capitalize.\n * @returns {string} Returns the capitalized string.\n * @example\n *\n * _.capitalize('FRED');\n * // => 'Fred'\n */\n function capitalize(string) {\n return upperFirst(toString(string).toLowerCase());\n }\n\n /**\n * Deburrs `string` by converting\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n * letters to basic Latin letters and removing\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to deburr.\n * @returns {string} Returns the deburred string.\n * @example\n *\n * _.deburr('déjà vu');\n * // => 'deja vu'\n */\n function deburr(string) {\n string = toString(string);\n return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n }\n\n /**\n * Checks if `string` ends with the given target string.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {string} [target] The string to search for.\n * @param {number} [position=string.length] The position to search up to.\n * @returns {boolean} Returns `true` if `string` ends with `target`,\n * else `false`.\n * @example\n *\n * _.endsWith('abc', 'c');\n * // => true\n *\n * _.endsWith('abc', 'b');\n * // => false\n *\n * _.endsWith('abc', 'b', 2);\n * // => true\n */\n function endsWith(string, target, position) {\n string = toString(string);\n target = baseToString(target);\n\n var length = string.length;\n position = position === undefined\n ? length\n : baseClamp(toInteger(position), 0, length);\n\n var end = position;\n position -= target.length;\n return position >= 0 && string.slice(position, end) == target;\n }\n\n /**\n * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n * corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional\n * characters use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value. See\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * When working with HTML you should always\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n * XSS vectors.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function escape(string) {\n string = toString(string);\n return (string && reHasUnescapedHtml.test(string))\n ? string.replace(reUnescapedHtml, escapeHtmlChar)\n : string;\n }\n\n /**\n * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escapeRegExp('[lodash](https://lodash.com/)');\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n */\n function escapeRegExp(string) {\n string = toString(string);\n return (string && reHasRegExpChar.test(string))\n ? string.replace(reRegExpChar, '\\\\$&')\n : string;\n }\n\n /**\n * Converts `string` to\n * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the kebab cased string.\n * @example\n *\n * _.kebabCase('Foo Bar');\n * // => 'foo-bar'\n *\n * _.kebabCase('fooBar');\n * // => 'foo-bar'\n *\n * _.kebabCase('__FOO_BAR__');\n * // => 'foo-bar'\n */\n var kebabCase = createCompounder(function(result, word, index) {\n return result + (index ? '-' : '') + word.toLowerCase();\n });\n\n /**\n * Converts `string`, as space separated words, to lower case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the lower cased string.\n * @example\n *\n * _.lowerCase('--Foo-Bar--');\n * // => 'foo bar'\n *\n * _.lowerCase('fooBar');\n * // => 'foo bar'\n *\n * _.lowerCase('__FOO_BAR__');\n * // => 'foo bar'\n */\n var lowerCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + word.toLowerCase();\n });\n\n /**\n * Converts the first character of `string` to lower case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.lowerFirst('Fred');\n * // => 'fred'\n *\n * _.lowerFirst('FRED');\n * // => 'fRED'\n */\n var lowerFirst = createCaseFirst('toLowerCase');\n\n /**\n * Pads `string` on the left and right sides if it's shorter than `length`.\n * Padding characters are truncated if they can't be evenly divided by `length`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.pad('abc', 8);\n * // => ' abc '\n *\n * _.pad('abc', 8, '_-');\n * // => '_-abc_-_'\n *\n * _.pad('abc', 3);\n * // => 'abc'\n */\n function pad(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n if (!length || strLength >= length) {\n return string;\n }\n var mid = (length - strLength) / 2;\n return (\n createPadding(nativeFloor(mid), chars) +\n string +\n createPadding(nativeCeil(mid), chars)\n );\n }\n\n /**\n * Pads `string` on the right side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padEnd('abc', 6);\n * // => 'abc '\n *\n * _.padEnd('abc', 6, '_-');\n * // => 'abc_-_'\n *\n * _.padEnd('abc', 3);\n * // => 'abc'\n */\n function padEnd(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (string + createPadding(length - strLength, chars))\n : string;\n }\n\n /**\n * Pads `string` on the left side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padStart('abc', 6);\n * // => ' abc'\n *\n * _.padStart('abc', 6, '_-');\n * // => '_-_abc'\n *\n * _.padStart('abc', 3);\n * // => 'abc'\n */\n function padStart(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (createPadding(length - strLength, chars) + string)\n : string;\n }\n\n /**\n * Converts `string` to an integer of the specified radix. If `radix` is\n * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n * hexadecimal, in which case a `radix` of `16` is used.\n *\n * **Note:** This method aligns with the\n * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category String\n * @param {string} string The string to convert.\n * @param {number} [radix=10] The radix to interpret `value` by.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.parseInt('08');\n * // => 8\n *\n * _.map(['6', '08', '10'], _.parseInt);\n * // => [6, 8, 10]\n */\n function parseInt(string, radix, guard) {\n if (guard || radix == null) {\n radix = 0;\n } else if (radix) {\n radix = +radix;\n }\n return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n }\n\n /**\n * Repeats the given string `n` times.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to repeat.\n * @param {number} [n=1] The number of times to repeat the string.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the repeated string.\n * @example\n *\n * _.repeat('*', 3);\n * // => '***'\n *\n * _.repeat('abc', 2);\n * // => 'abcabc'\n *\n * _.repeat('abc', 0);\n * // => ''\n */\n function repeat(string, n, guard) {\n if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n n = 1;\n } else {\n n = toInteger(n);\n }\n return baseRepeat(toString(string), n);\n }\n\n /**\n * Replaces matches for `pattern` in `string` with `replacement`.\n *\n * **Note:** This method is based on\n * [`String#replace`](https://mdn.io/String/replace).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to modify.\n * @param {RegExp|string} pattern The pattern to replace.\n * @param {Function|string} replacement The match replacement.\n * @returns {string} Returns the modified string.\n * @example\n *\n * _.replace('Hi Fred', 'Fred', 'Barney');\n * // => 'Hi Barney'\n */\n function replace() {\n var args = arguments,\n string = toString(args[0]);\n\n return args.length < 3 ? string : string.replace(args[1], args[2]);\n }\n\n /**\n * Converts `string` to\n * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the snake cased string.\n * @example\n *\n * _.snakeCase('Foo Bar');\n * // => 'foo_bar'\n *\n * _.snakeCase('fooBar');\n * // => 'foo_bar'\n *\n * _.snakeCase('--FOO-BAR--');\n * // => 'foo_bar'\n */\n var snakeCase = createCompounder(function(result, word, index) {\n return result + (index ? '_' : '') + word.toLowerCase();\n });\n\n /**\n * Splits `string` by `separator`.\n *\n * **Note:** This method is based on\n * [`String#split`](https://mdn.io/String/split).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to split.\n * @param {RegExp|string} separator The separator pattern to split by.\n * @param {number} [limit] The length to truncate results to.\n * @returns {Array} Returns the string segments.\n * @example\n *\n * _.split('a-b-c', '-', 2);\n * // => ['a', 'b']\n */\n function split(string, separator, limit) {\n if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n separator = limit = undefined;\n }\n limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n if (!limit) {\n return [];\n }\n string = toString(string);\n if (string && (\n typeof separator == 'string' ||\n (separator != null && !isRegExp(separator))\n )) {\n separator = baseToString(separator);\n if (!separator && hasUnicode(string)) {\n return castSlice(stringToArray(string), 0, limit);\n }\n }\n return string.split(separator, limit);\n }\n\n /**\n * Converts `string` to\n * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n *\n * @static\n * @memberOf _\n * @since 3.1.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the start cased string.\n * @example\n *\n * _.startCase('--foo-bar--');\n * // => 'Foo Bar'\n *\n * _.startCase('fooBar');\n * // => 'Foo Bar'\n *\n * _.startCase('__FOO_BAR__');\n * // => 'FOO BAR'\n */\n var startCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + upperFirst(word);\n });\n\n /**\n * Checks if `string` starts with the given target string.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {string} [target] The string to search for.\n * @param {number} [position=0] The position to search from.\n * @returns {boolean} Returns `true` if `string` starts with `target`,\n * else `false`.\n * @example\n *\n * _.startsWith('abc', 'a');\n * // => true\n *\n * _.startsWith('abc', 'b');\n * // => false\n *\n * _.startsWith('abc', 'b', 1);\n * // => true\n */\n function startsWith(string, target, position) {\n string = toString(string);\n position = position == null\n ? 0\n : baseClamp(toInteger(position), 0, string.length);\n\n target = baseToString(target);\n return string.slice(position, position + target.length) == target;\n }\n\n /**\n * Creates a compiled template function that can interpolate data properties\n * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n * properties may be accessed as free variables in the template. If a setting\n * object is given, it takes precedence over `_.templateSettings` values.\n *\n * **Note:** In the development build `_.template` utilizes\n * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n * for easier debugging.\n *\n * For more information on precompiling templates see\n * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n *\n * For more information on Chrome extension sandboxes see\n * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The template string.\n * @param {Object} [options={}] The options object.\n * @param {RegExp} [options.escape=_.templateSettings.escape]\n * The HTML \"escape\" delimiter.\n * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n * The \"evaluate\" delimiter.\n * @param {Object} [options.imports=_.templateSettings.imports]\n * An object to import into the template as free variables.\n * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n * The \"interpolate\" delimiter.\n * @param {string} [options.sourceURL='lodash.templateSources[n]']\n * The sourceURL of the compiled template.\n * @param {string} [options.variable='obj']\n * The data object variable name.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the compiled template function.\n * @example\n *\n * // Use the \"interpolate\" delimiter to create a compiled template.\n * var compiled = _.template('hello <%= user %>!');\n * compiled({ 'user': 'fred' });\n * // => 'hello fred!'\n *\n * // Use the HTML \"escape\" delimiter to escape data property values.\n * var compiled = _.template('<b><%- value %></b>');\n * compiled({ 'value': '<script>' });\n * // => '<b><script></b>'\n *\n * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n * compiled({ 'users': ['fred', 'barney'] });\n * // => '<li>fred</li><li>barney</li>'\n *\n * // Use the internal `print` function in \"evaluate\" delimiters.\n * var compiled = _.template('<% print(\"hello \" + user); %>!');\n * compiled({ 'user': 'barney' });\n * // => 'hello barney!'\n *\n * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n * // Disable support by replacing the \"interpolate\" delimiter.\n * var compiled = _.template('hello ${ user }!');\n * compiled({ 'user': 'pebbles' });\n * // => 'hello pebbles!'\n *\n * // Use backslashes to treat delimiters as plain text.\n * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n * compiled({ 'value': 'ignored' });\n * // => '<%- value %>'\n *\n * // Use the `imports` option to import `jQuery` as `jq`.\n * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n * compiled({ 'users': ['fred', 'barney'] });\n * // => '<li>fred</li><li>barney</li>'\n *\n * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n * compiled(data);\n * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n *\n * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n * compiled.source;\n * // => function(data) {\n * // var __t, __p = '';\n * // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n * // return __p;\n * // }\n *\n * // Use custom template delimiters.\n * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n * var compiled = _.template('hello {{ user }}!');\n * compiled({ 'user': 'mustache' });\n * // => 'hello mustache!'\n *\n * // Use the `source` property to inline compiled templates for meaningful\n * // line numbers in error messages and stack traces.\n * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n * var JST = {\\\n * \"main\": ' + _.template(mainText).source + '\\\n * };\\\n * ');\n */\n function template(string, options, guard) {\n // Based on John Resig's `tmpl` implementation\n // (http://ejohn.org/blog/javascript-micro-templating/)\n // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n var settings = lodash.templateSettings;\n\n if (guard && isIterateeCall(string, options, guard)) {\n options = undefined;\n }\n string = toString(string);\n options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n importsKeys = keys(imports),\n importsValues = baseValues(imports, importsKeys);\n\n var isEscaping,\n isEvaluating,\n index = 0,\n interpolate = options.interpolate || reNoMatch,\n source = \"__p += '\";\n\n // Compile the regexp to match each delimiter.\n var reDelimiters = RegExp(\n (options.escape || reNoMatch).source + '|' +\n interpolate.source + '|' +\n (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n (options.evaluate || reNoMatch).source + '|$'\n , 'g');\n\n // Use a sourceURL for easier debugging.\n // The sourceURL gets injected into the source that's eval-ed, so be careful\n // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n // and escape the comment, thus injecting code that gets evaled.\n var sourceURL = '//# sourceURL=' +\n (hasOwnProperty.call(options, 'sourceURL')\n ? (options.sourceURL + '').replace(/\\s/g, ' ')\n : ('lodash.templateSources[' + (++templateCounter) + ']')\n ) + '\\n';\n\n string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n interpolateValue || (interpolateValue = esTemplateValue);\n\n // Escape characters that can't be included in string literals.\n source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n // Replace delimiters with snippets.\n if (escapeValue) {\n isEscaping = true;\n source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n }\n if (evaluateValue) {\n isEvaluating = true;\n source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n }\n if (interpolateValue) {\n source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n }\n index = offset + match.length;\n\n // The JS engine embedded in Adobe products needs `match` returned in\n // order to produce the correct `offset` value.\n return match;\n });\n\n source += \"';\\n\";\n\n // If `variable` is not specified wrap a with-statement around the generated\n // code to add the data object to the top of the scope chain.\n var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n if (!variable) {\n source = 'with (obj) {\\n' + source + '\\n}\\n';\n }\n // Cleanup code by stripping empty strings.\n source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n .replace(reEmptyStringMiddle, '$1')\n .replace(reEmptyStringTrailing, '$1;');\n\n // Frame code as the function body.\n source = 'function(' + (variable || 'obj') + ') {\\n' +\n (variable\n ? ''\n : 'obj || (obj = {});\\n'\n ) +\n \"var __t, __p = ''\" +\n (isEscaping\n ? ', __e = _.escape'\n : ''\n ) +\n (isEvaluating\n ? ', __j = Array.prototype.join;\\n' +\n \"function print() { __p += __j.call(arguments, '') }\\n\"\n : ';\\n'\n ) +\n source +\n 'return __p\\n}';\n\n var result = attempt(function() {\n return Function(importsKeys, sourceURL + 'return ' + source)\n .apply(undefined, importsValues);\n });\n\n // Provide the compiled function's source by its `toString` method or\n // the `source` property as a convenience for inlining compiled templates.\n result.source = source;\n if (isError(result)) {\n throw result;\n }\n return result;\n }\n\n /**\n * Converts `string`, as a whole, to lower case just like\n * [String#toLowerCase](https://mdn.io/toLowerCase).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the lower cased string.\n * @example\n *\n * _.toLower('--Foo-Bar--');\n * // => '--foo-bar--'\n *\n * _.toLower('fooBar');\n * // => 'foobar'\n *\n * _.toLower('__FOO_BAR__');\n * // => '__foo_bar__'\n */\n function toLower(value) {\n return toString(value).toLowerCase();\n }\n\n /**\n * Converts `string`, as a whole, to upper case just like\n * [String#toUpperCase](https://mdn.io/toUpperCase).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the upper cased string.\n * @example\n *\n * _.toUpper('--foo-bar--');\n * // => '--FOO-BAR--'\n *\n * _.toUpper('fooBar');\n * // => 'FOOBAR'\n *\n * _.toUpper('__foo_bar__');\n * // => '__FOO_BAR__'\n */\n function toUpper(value) {\n return toString(value).toUpperCase();\n }\n\n /**\n * Removes leading and trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trim(' abc ');\n * // => 'abc'\n *\n * _.trim('-_-abc-_-', '_-');\n * // => 'abc'\n *\n * _.map([' foo ', ' bar '], _.trim);\n * // => ['foo', 'bar']\n */\n function trim(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.replace(reTrim, '');\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n chrSymbols = stringToArray(chars),\n start = charsStartIndex(strSymbols, chrSymbols),\n end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n return castSlice(strSymbols, start, end).join('');\n }\n\n /**\n * Removes trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trimEnd(' abc ');\n * // => ' abc'\n *\n * _.trimEnd('-_-abc-_-', '_-');\n * // => '-_-abc'\n */\n function trimEnd(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.replace(reTrimEnd, '');\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n return castSlice(strSymbols, 0, end).join('');\n }\n\n /**\n * Removes leading whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trimStart(' abc ');\n * // => 'abc '\n *\n * _.trimStart('-_-abc-_-', '_-');\n * // => 'abc-_-'\n */\n function trimStart(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.replace(reTrimStart, '');\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n start = charsStartIndex(strSymbols, stringToArray(chars));\n\n return castSlice(strSymbols, start).join('');\n }\n\n /**\n * Truncates `string` if it's longer than the given maximum string length.\n * The last characters of the truncated string are replaced with the omission\n * string which defaults to \"...\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to truncate.\n * @param {Object} [options={}] The options object.\n * @param {number} [options.length=30] The maximum string length.\n * @param {string} [options.omission='...'] The string to indicate text is omitted.\n * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n * @returns {string} Returns the truncated string.\n * @example\n *\n * _.truncate('hi-diddly-ho there, neighborino');\n * // => 'hi-diddly-ho there, neighbo...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'length': 24,\n * 'separator': ' '\n * });\n * // => 'hi-diddly-ho there,...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'length': 24,\n * 'separator': /,? +/\n * });\n * // => 'hi-diddly-ho there...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'omission': ' [...]'\n * });\n * // => 'hi-diddly-ho there, neig [...]'\n */\n function truncate(string, options) {\n var length = DEFAULT_TRUNC_LENGTH,\n omission = DEFAULT_TRUNC_OMISSION;\n\n if (isObject(options)) {\n var separator = 'separator' in options ? options.separator : separator;\n length = 'length' in options ? toInteger(options.length) : length;\n omission = 'omission' in options ? baseToString(options.omission) : omission;\n }\n string = toString(string);\n\n var strLength = string.length;\n if (hasUnicode(string)) {\n var strSymbols = stringToArray(string);\n strLength = strSymbols.length;\n }\n if (length >= strLength) {\n return string;\n }\n var end = length - stringSize(omission);\n if (end < 1) {\n return omission;\n }\n var result = strSymbols\n ? castSlice(strSymbols, 0, end).join('')\n : string.slice(0, end);\n\n if (separator === undefined) {\n return result + omission;\n }\n if (strSymbols) {\n end += (result.length - end);\n }\n if (isRegExp(separator)) {\n if (string.slice(end).search(separator)) {\n var match,\n substring = result;\n\n if (!separator.global) {\n separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n }\n separator.lastIndex = 0;\n while ((match = separator.exec(substring))) {\n var newEnd = match.index;\n }\n result = result.slice(0, newEnd === undefined ? end : newEnd);\n }\n } else if (string.indexOf(baseToString(separator), end) != end) {\n var index = result.lastIndexOf(separator);\n if (index > -1) {\n result = result.slice(0, index);\n }\n }\n return result + omission;\n }\n\n /**\n * The inverse of `_.escape`; this method converts the HTML entities\n * `&`, `<`, `>`, `"`, and `'` in `string` to\n * their corresponding characters.\n *\n * **Note:** No other HTML entities are unescaped. To unescape additional\n * HTML entities use a third-party library like [_he_](https://mths.be/he).\n *\n * @static\n * @memberOf _\n * @since 0.6.0\n * @category String\n * @param {string} [string=''] The string to unescape.\n * @returns {string} Returns the unescaped string.\n * @example\n *\n * _.unescape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function unescape(string) {\n string = toString(string);\n return (string && reHasEscapedHtml.test(string))\n ? string.replace(reEscapedHtml, unescapeHtmlChar)\n : string;\n }\n\n /**\n * Converts `string`, as space separated words, to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the upper cased string.\n * @example\n *\n * _.upperCase('--foo-bar');\n * // => 'FOO BAR'\n *\n * _.upperCase('fooBar');\n * // => 'FOO BAR'\n *\n * _.upperCase('__foo_bar__');\n * // => 'FOO BAR'\n */\n var upperCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + word.toUpperCase();\n });\n\n /**\n * Converts the first character of `string` to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.upperFirst('fred');\n * // => 'Fred'\n *\n * _.upperFirst('FRED');\n * // => 'FRED'\n */\n var upperFirst = createCaseFirst('toUpperCase');\n\n /**\n * Splits `string` into an array of its words.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {RegExp|string} [pattern] The pattern to match words.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the words of `string`.\n * @example\n *\n * _.words('fred, barney, & pebbles');\n * // => ['fred', 'barney', 'pebbles']\n *\n * _.words('fred, barney, & pebbles', /[^, ]+/g);\n * // => ['fred', 'barney', '&', 'pebbles']\n */\n function words(string, pattern, guard) {\n string = toString(string);\n pattern = guard ? undefined : pattern;\n\n if (pattern === undefined) {\n return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n }\n return string.match(pattern) || [];\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Attempts to invoke `func`, returning either the result or the caught error\n * object. Any additional arguments are provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Function} func The function to attempt.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {*} Returns the `func` result or error object.\n * @example\n *\n * // Avoid throwing errors for invalid selectors.\n * var elements = _.attempt(function(selector) {\n * return document.querySelectorAll(selector);\n * }, '>_>');\n *\n * if (_.isError(elements)) {\n * elements = [];\n * }\n */\n var attempt = baseRest(function(func, args) {\n try {\n return apply(func, undefined, args);\n } catch (e) {\n return isError(e) ? e : new Error(e);\n }\n });\n\n /**\n * Binds methods of an object to the object itself, overwriting the existing\n * method.\n *\n * **Note:** This method doesn't set the \"length\" property of bound functions.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {Object} object The object to bind and assign the bound methods to.\n * @param {...(string|string[])} methodNames The object method names to bind.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var view = {\n * 'label': 'docs',\n * 'click': function() {\n * console.log('clicked ' + this.label);\n * }\n * };\n *\n * _.bindAll(view, ['click']);\n * jQuery(element).on('click', view.click);\n * // => Logs 'clicked docs' when clicked.\n */\n var bindAll = flatRest(function(object, methodNames) {\n arrayEach(methodNames, function(key) {\n key = toKey(key);\n baseAssignValue(object, key, bind(object[key], object));\n });\n return object;\n });\n\n /**\n * Creates a function that iterates over `pairs` and invokes the corresponding\n * function of the first predicate to return truthy. The predicate-function\n * pairs are invoked with the `this` binding and arguments of the created\n * function.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {Array} pairs The predicate-function pairs.\n * @returns {Function} Returns the new composite function.\n * @example\n *\n * var func = _.cond([\n * [_.matches({ 'a': 1 }), _.constant('matches A')],\n * [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n * [_.stubTrue, _.constant('no match')]\n * ]);\n *\n * func({ 'a': 1, 'b': 2 });\n * // => 'matches A'\n *\n * func({ 'a': 0, 'b': 1 });\n * // => 'matches B'\n *\n * func({ 'a': '1', 'b': '2' });\n * // => 'no match'\n */\n function cond(pairs) {\n var length = pairs == null ? 0 : pairs.length,\n toIteratee = getIteratee();\n\n pairs = !length ? [] : arrayMap(pairs, function(pair) {\n if (typeof pair[1] != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return [toIteratee(pair[0]), pair[1]];\n });\n\n return baseRest(function(args) {\n var index = -1;\n while (++index < length) {\n var pair = pairs[index];\n if (apply(pair[0], this, args)) {\n return apply(pair[1], this, args);\n }\n }\n });\n }\n\n /**\n * Creates a function that invokes the predicate properties of `source` with\n * the corresponding property values of a given object, returning `true` if\n * all predicates return truthy, else `false`.\n *\n * **Note:** The created function is equivalent to `_.conformsTo` with\n * `source` partially applied.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {Object} source The object of property predicates to conform to.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 2, 'b': 1 },\n * { 'a': 1, 'b': 2 }\n * ];\n *\n * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n * // => [{ 'a': 1, 'b': 2 }]\n */\n function conforms(source) {\n return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\n function constant(value) {\n return function() {\n return value;\n };\n }\n\n /**\n * Checks `value` to determine whether a default value should be returned in\n * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n * or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.14.0\n * @category Util\n * @param {*} value The value to check.\n * @param {*} defaultValue The default value.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * _.defaultTo(1, 10);\n * // => 1\n *\n * _.defaultTo(undefined, 10);\n * // => 10\n */\n function defaultTo(value, defaultValue) {\n return (value == null || value !== value) ? defaultValue : value;\n }\n\n /**\n * Creates a function that returns the result of invoking the given functions\n * with the `this` binding of the created function, where each successive\n * invocation is supplied the return value of the previous.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flowRight\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var addSquare = _.flow([_.add, square]);\n * addSquare(1, 2);\n * // => 9\n */\n var flow = createFlow();\n\n /**\n * This method is like `_.flow` except that it creates a function that\n * invokes the given functions from right to left.\n *\n * @static\n * @since 3.0.0\n * @memberOf _\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flow\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var addSquare = _.flowRight([square, _.add]);\n * addSquare(1, 2);\n * // => 9\n */\n var flowRight = createFlow(true);\n\n /**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\n function identity(value) {\n return value;\n }\n\n /**\n * Creates a function that invokes `func` with the arguments of the created\n * function. If `func` is a property name, the created function returns the\n * property value for a given element. If `func` is an array or object, the\n * created function returns `true` for elements that contain the equivalent\n * source properties, otherwise it returns `false`.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Util\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @returns {Function} Returns the callback.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, _.iteratee(['user', 'fred']));\n * // => [{ 'user': 'fred', 'age': 40 }]\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, _.iteratee('user'));\n * // => ['barney', 'fred']\n *\n * // Create custom iteratee shorthands.\n * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n * return !_.isRegExp(func) ? iteratee(func) : function(string) {\n * return func.test(string);\n * };\n * });\n *\n * _.filter(['abc', 'def'], /ef/);\n * // => ['def']\n */\n function iteratee(func) {\n return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that performs a partial deep comparison between a given\n * object and `source`, returning `true` if the given object has equivalent\n * property values, else `false`.\n *\n * **Note:** The created function is equivalent to `_.isMatch` with `source`\n * partially applied.\n *\n * Partial comparisons will match empty array and empty object `source`\n * values against any array or object value, respectively. See `_.isEqual`\n * for a list of supported value comparisons.\n *\n * **Note:** Multiple values can be checked by combining several matchers\n * using `_.overSome`\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 1, 'b': 2, 'c': 3 },\n * { 'a': 4, 'b': 5, 'c': 6 }\n * ];\n *\n * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n *\n * // Checking for several possible values\n * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n */\n function matches(source) {\n return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that performs a partial deep comparison between the\n * value at `path` of a given object to `srcValue`, returning `true` if the\n * object value is equivalent, else `false`.\n *\n * **Note:** Partial comparisons will match empty array and empty object\n * `srcValue` values against any array or object value, respectively. See\n * `_.isEqual` for a list of supported value comparisons.\n *\n * **Note:** Multiple values can be checked by combining several matchers\n * using `_.overSome`\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 1, 'b': 2, 'c': 3 },\n * { 'a': 4, 'b': 5, 'c': 6 }\n * ];\n *\n * _.find(objects, _.matchesProperty('a', 4));\n * // => { 'a': 4, 'b': 5, 'c': 6 }\n *\n * // Checking for several possible values\n * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n */\n function matchesProperty(path, srcValue) {\n return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that invokes the method at `path` of a given object.\n * Any additional arguments are provided to the invoked method.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Util\n * @param {Array|string} path The path of the method to invoke.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {Function} Returns the new invoker function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': _.constant(2) } },\n * { 'a': { 'b': _.constant(1) } }\n * ];\n *\n * _.map(objects, _.method('a.b'));\n * // => [2, 1]\n *\n * _.map(objects, _.method(['a', 'b']));\n * // => [2, 1]\n */\n var method = baseRest(function(path, args) {\n return function(object) {\n return baseInvoke(object, path, args);\n };\n });\n\n /**\n * The opposite of `_.method`; this method creates a function that invokes\n * the method at a given path of `object`. Any additional arguments are\n * provided to the invoked method.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Util\n * @param {Object} object The object to query.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {Function} Returns the new invoker function.\n * @example\n *\n * var array = _.times(3, _.constant),\n * object = { 'a': array, 'b': array, 'c': array };\n *\n * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n * // => [2, 0]\n *\n * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n * // => [2, 0]\n */\n var methodOf = baseRest(function(object, args) {\n return function(path) {\n return baseInvoke(object, path, args);\n };\n });\n\n /**\n * Adds all own enumerable string keyed function properties of a source\n * object to the destination object. If `object` is a function, then methods\n * are added to its prototype as well.\n *\n * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n * avoid conflicts caused by modifying the original.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {Function|Object} [object=lodash] The destination object.\n * @param {Object} source The object of functions to add.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n * @returns {Function|Object} Returns `object`.\n * @example\n *\n * function vowels(string) {\n * return _.filter(string, function(v) {\n * return /[aeiou]/i.test(v);\n * });\n * }\n *\n * _.mixin({ 'vowels': vowels });\n * _.vowels('fred');\n * // => ['e']\n *\n * _('fred').vowels().value();\n * // => ['e']\n *\n * _.mixin({ 'vowels': vowels }, { 'chain': false });\n * _('fred').vowels();\n * // => ['e']\n */\n function mixin(object, source, options) {\n var props = keys(source),\n methodNames = baseFunctions(source, props);\n\n if (options == null &&\n !(isObject(source) && (methodNames.length || !props.length))) {\n options = source;\n source = object;\n object = this;\n methodNames = baseFunctions(source, keys(source));\n }\n var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n isFunc = isFunction(object);\n\n arrayEach(methodNames, function(methodName) {\n var func = source[methodName];\n object[methodName] = func;\n if (isFunc) {\n object.prototype[methodName] = function() {\n var chainAll = this.__chain__;\n if (chain || chainAll) {\n var result = object(this.__wrapped__),\n actions = result.__actions__ = copyArray(this.__actions__);\n\n actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n result.__chain__ = chainAll;\n return result;\n }\n return func.apply(object, arrayPush([this.value()], arguments));\n };\n }\n });\n\n return object;\n }\n\n /**\n * Reverts the `_` variable to its previous value and returns a reference to\n * the `lodash` function.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @returns {Function} Returns the `lodash` function.\n * @example\n *\n * var lodash = _.noConflict();\n */\n function noConflict() {\n if (root._ === this) {\n root._ = oldDash;\n }\n return this;\n }\n\n /**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\n function noop() {\n // No operation performed.\n }\n\n /**\n * Creates a function that gets the argument at index `n`. If `n` is negative,\n * the nth argument from the end is returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {number} [n=0] The index of the argument to return.\n * @returns {Function} Returns the new pass-thru function.\n * @example\n *\n * var func = _.nthArg(1);\n * func('a', 'b', 'c', 'd');\n * // => 'b'\n *\n * var func = _.nthArg(-2);\n * func('a', 'b', 'c', 'd');\n * // => 'c'\n */\n function nthArg(n) {\n n = toInteger(n);\n return baseRest(function(args) {\n return baseNth(args, n);\n });\n }\n\n /**\n * Creates a function that invokes `iteratees` with the arguments it receives\n * and returns their results.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n * The iteratees to invoke.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.over([Math.max, Math.min]);\n *\n * func(1, 2, 3, 4);\n * // => [4, 1]\n */\n var over = createOver(arrayMap);\n\n /**\n * Creates a function that checks if **all** of the `predicates` return\n * truthy when invoked with the arguments it receives.\n *\n * Following shorthands are possible for providing predicates.\n * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [predicates=[_.identity]]\n * The predicates to check.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.overEvery([Boolean, isFinite]);\n *\n * func('1');\n * // => true\n *\n * func(null);\n * // => false\n *\n * func(NaN);\n * // => false\n */\n var overEvery = createOver(arrayEvery);\n\n /**\n * Creates a function that checks if **any** of the `predicates` return\n * truthy when invoked with the arguments it receives.\n *\n * Following shorthands are possible for providing predicates.\n * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [predicates=[_.identity]]\n * The predicates to check.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.overSome([Boolean, isFinite]);\n *\n * func('1');\n * // => true\n *\n * func(null);\n * // => true\n *\n * func(NaN);\n * // => false\n *\n * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\n */\n var overSome = createOver(arraySome);\n\n /**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': 2 } },\n * { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\n function property(path) {\n return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n }\n\n /**\n * The opposite of `_.property`; this method creates a function that returns\n * the value at a given path of `object`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var array = [0, 1, 2],\n * object = { 'a': array, 'b': array, 'c': array };\n *\n * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n * // => [2, 0]\n *\n * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n * // => [2, 0]\n */\n function propertyOf(object) {\n return function(path) {\n return object == null ? undefined : baseGet(object, path);\n };\n }\n\n /**\n * Creates an array of numbers (positive and/or negative) progressing from\n * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n * `start` is specified without an `end` or `step`. If `end` is not specified,\n * it's set to `start` with `start` then set to `0`.\n *\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\n * floating-point values which can produce unexpected results.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @param {number} [step=1] The value to increment or decrement by.\n * @returns {Array} Returns the range of numbers.\n * @see _.inRange, _.rangeRight\n * @example\n *\n * _.range(4);\n * // => [0, 1, 2, 3]\n *\n * _.range(-4);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 5);\n * // => [1, 2, 3, 4]\n *\n * _.range(0, 20, 5);\n * // => [0, 5, 10, 15]\n *\n * _.range(0, -4, -1);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 4, 0);\n * // => [1, 1, 1]\n *\n * _.range(0);\n * // => []\n */\n var range = createRange();\n\n /**\n * This method is like `_.range` except that it populates values in\n * descending order.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @param {number} [step=1] The value to increment or decrement by.\n * @returns {Array} Returns the range of numbers.\n * @see _.inRange, _.range\n * @example\n *\n * _.rangeRight(4);\n * // => [3, 2, 1, 0]\n *\n * _.rangeRight(-4);\n * // => [-3, -2, -1, 0]\n *\n * _.rangeRight(1, 5);\n * // => [4, 3, 2, 1]\n *\n * _.rangeRight(0, 20, 5);\n * // => [15, 10, 5, 0]\n *\n * _.rangeRight(0, -4, -1);\n * // => [-3, -2, -1, 0]\n *\n * _.rangeRight(1, 4, 0);\n * // => [1, 1, 1]\n *\n * _.rangeRight(0);\n * // => []\n */\n var rangeRight = createRange(true);\n\n /**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\n function stubArray() {\n return [];\n }\n\n /**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\n function stubFalse() {\n return false;\n }\n\n /**\n * This method returns a new empty object.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Object} Returns the new empty object.\n * @example\n *\n * var objects = _.times(2, _.stubObject);\n *\n * console.log(objects);\n * // => [{}, {}]\n *\n * console.log(objects[0] === objects[1]);\n * // => false\n */\n function stubObject() {\n return {};\n }\n\n /**\n * This method returns an empty string.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {string} Returns the empty string.\n * @example\n *\n * _.times(2, _.stubString);\n * // => ['', '']\n */\n function stubString() {\n return '';\n }\n\n /**\n * This method returns `true`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `true`.\n * @example\n *\n * _.times(2, _.stubTrue);\n * // => [true, true]\n */\n function stubTrue() {\n return true;\n }\n\n /**\n * Invokes the iteratee `n` times, returning an array of the results of\n * each invocation. The iteratee is invoked with one argument; (index).\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n * @example\n *\n * _.times(3, String);\n * // => ['0', '1', '2']\n *\n * _.times(4, _.constant(0));\n * // => [0, 0, 0, 0]\n */\n function times(n, iteratee) {\n n = toInteger(n);\n if (n < 1 || n > MAX_SAFE_INTEGER) {\n return [];\n }\n var index = MAX_ARRAY_LENGTH,\n length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n iteratee = getIteratee(iteratee);\n n -= MAX_ARRAY_LENGTH;\n\n var result = baseTimes(length, iteratee);\n while (++index < n) {\n iteratee(index);\n }\n return result;\n }\n\n /**\n * Converts `value` to a property path array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {*} value The value to convert.\n * @returns {Array} Returns the new property path array.\n * @example\n *\n * _.toPath('a.b.c');\n * // => ['a', 'b', 'c']\n *\n * _.toPath('a[0].b.c');\n * // => ['a', '0', 'b', 'c']\n */\n function toPath(value) {\n if (isArray(value)) {\n return arrayMap(value, toKey);\n }\n return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n }\n\n /**\n * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {string} [prefix=''] The value to prefix the ID with.\n * @returns {string} Returns the unique ID.\n * @example\n *\n * _.uniqueId('contact_');\n * // => 'contact_104'\n *\n * _.uniqueId();\n * // => '105'\n */\n function uniqueId(prefix) {\n var id = ++idCounter;\n return toString(prefix) + id;\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Adds two numbers.\n *\n * @static\n * @memberOf _\n * @since 3.4.0\n * @category Math\n * @param {number} augend The first number in an addition.\n * @param {number} addend The second number in an addition.\n * @returns {number} Returns the total.\n * @example\n *\n * _.add(6, 4);\n * // => 10\n */\n var add = createMathOperation(function(augend, addend) {\n return augend + addend;\n }, 0);\n\n /**\n * Computes `number` rounded up to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round up.\n * @param {number} [precision=0] The precision to round up to.\n * @returns {number} Returns the rounded up number.\n * @example\n *\n * _.ceil(4.006);\n * // => 5\n *\n * _.ceil(6.004, 2);\n * // => 6.01\n *\n * _.ceil(6040, -2);\n * // => 6100\n */\n var ceil = createRound('ceil');\n\n /**\n * Divide two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {number} dividend The first number in a division.\n * @param {number} divisor The second number in a division.\n * @returns {number} Returns the quotient.\n * @example\n *\n * _.divide(6, 4);\n * // => 1.5\n */\n var divide = createMathOperation(function(dividend, divisor) {\n return dividend / divisor;\n }, 1);\n\n /**\n * Computes `number` rounded down to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round down.\n * @param {number} [precision=0] The precision to round down to.\n * @returns {number} Returns the rounded down number.\n * @example\n *\n * _.floor(4.006);\n * // => 4\n *\n * _.floor(0.046, 2);\n * // => 0.04\n *\n * _.floor(4060, -2);\n * // => 4000\n */\n var floor = createRound('floor');\n\n /**\n * Computes the maximum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the maximum value.\n * @example\n *\n * _.max([4, 2, 8, 6]);\n * // => 8\n *\n * _.max([]);\n * // => undefined\n */\n function max(array) {\n return (array && array.length)\n ? baseExtremum(array, identity, baseGt)\n : undefined;\n }\n\n /**\n * This method is like `_.max` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * the value is ranked. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {*} Returns the maximum value.\n * @example\n *\n * var objects = [{ 'n': 1 }, { 'n': 2 }];\n *\n * _.maxBy(objects, function(o) { return o.n; });\n * // => { 'n': 2 }\n *\n * // The `_.property` iteratee shorthand.\n * _.maxBy(objects, 'n');\n * // => { 'n': 2 }\n */\n function maxBy(array, iteratee) {\n return (array && array.length)\n ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n : undefined;\n }\n\n /**\n * Computes the mean of the values in `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {number} Returns the mean.\n * @example\n *\n * _.mean([4, 2, 8, 6]);\n * // => 5\n */\n function mean(array) {\n return baseMean(array, identity);\n }\n\n /**\n * This method is like `_.mean` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the value to be averaged.\n * The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the mean.\n * @example\n *\n * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n *\n * _.meanBy(objects, function(o) { return o.n; });\n * // => 5\n *\n * // The `_.property` iteratee shorthand.\n * _.meanBy(objects, 'n');\n * // => 5\n */\n function meanBy(array, iteratee) {\n return baseMean(array, getIteratee(iteratee, 2));\n }\n\n /**\n * Computes the minimum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * _.min([4, 2, 8, 6]);\n * // => 2\n *\n * _.min([]);\n * // => undefined\n */\n function min(array) {\n return (array && array.length)\n ? baseExtremum(array, identity, baseLt)\n : undefined;\n }\n\n /**\n * This method is like `_.min` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * the value is ranked. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * var objects = [{ 'n': 1 }, { 'n': 2 }];\n *\n * _.minBy(objects, function(o) { return o.n; });\n * // => { 'n': 1 }\n *\n * // The `_.property` iteratee shorthand.\n * _.minBy(objects, 'n');\n * // => { 'n': 1 }\n */\n function minBy(array, iteratee) {\n return (array && array.length)\n ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n : undefined;\n }\n\n /**\n * Multiply two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {number} multiplier The first number in a multiplication.\n * @param {number} multiplicand The second number in a multiplication.\n * @returns {number} Returns the product.\n * @example\n *\n * _.multiply(6, 4);\n * // => 24\n */\n var multiply = createMathOperation(function(multiplier, multiplicand) {\n return multiplier * multiplicand;\n }, 1);\n\n /**\n * Computes `number` rounded to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round.\n * @param {number} [precision=0] The precision to round to.\n * @returns {number} Returns the rounded number.\n * @example\n *\n * _.round(4.006);\n * // => 4\n *\n * _.round(4.006, 2);\n * // => 4.01\n *\n * _.round(4060, -2);\n * // => 4100\n */\n var round = createRound('round');\n\n /**\n * Subtract two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {number} minuend The first number in a subtraction.\n * @param {number} subtrahend The second number in a subtraction.\n * @returns {number} Returns the difference.\n * @example\n *\n * _.subtract(6, 4);\n * // => 2\n */\n var subtract = createMathOperation(function(minuend, subtrahend) {\n return minuend - subtrahend;\n }, 0);\n\n /**\n * Computes the sum of the values in `array`.\n *\n * @static\n * @memberOf _\n * @since 3.4.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {number} Returns the sum.\n * @example\n *\n * _.sum([4, 2, 8, 6]);\n * // => 20\n */\n function sum(array) {\n return (array && array.length)\n ? baseSum(array, identity)\n : 0;\n }\n\n /**\n * This method is like `_.sum` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the value to be summed.\n * The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the sum.\n * @example\n *\n * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n *\n * _.sumBy(objects, function(o) { return o.n; });\n * // => 20\n *\n * // The `_.property` iteratee shorthand.\n * _.sumBy(objects, 'n');\n * // => 20\n */\n function sumBy(array, iteratee) {\n return (array && array.length)\n ? baseSum(array, getIteratee(iteratee, 2))\n : 0;\n }\n\n /*------------------------------------------------------------------------*/\n\n // Add methods that return wrapped values in chain sequences.\n lodash.after = after;\n lodash.ary = ary;\n lodash.assign = assign;\n lodash.assignIn = assignIn;\n lodash.assignInWith = assignInWith;\n lodash.assignWith = assignWith;\n lodash.at = at;\n lodash.before = before;\n lodash.bind = bind;\n lodash.bindAll = bindAll;\n lodash.bindKey = bindKey;\n lodash.castArray = castArray;\n lodash.chain = chain;\n lodash.chunk = chunk;\n lodash.compact = compact;\n lodash.concat = concat;\n lodash.cond = cond;\n lodash.conforms = conforms;\n lodash.constant = constant;\n lodash.countBy = countBy;\n lodash.create = create;\n lodash.curry = curry;\n lodash.curryRight = curryRight;\n lodash.debounce = debounce;\n lodash.defaults = defaults;\n lodash.defaultsDeep = defaultsDeep;\n lodash.defer = defer;\n lodash.delay = delay;\n lodash.difference = difference;\n lodash.differenceBy = differenceBy;\n lodash.differenceWith = differenceWith;\n lodash.drop = drop;\n lodash.dropRight = dropRight;\n lodash.dropRightWhile = dropRightWhile;\n lodash.dropWhile = dropWhile;\n lodash.fill = fill;\n lodash.filter = filter;\n lodash.flatMap = flatMap;\n lodash.flatMapDeep = flatMapDeep;\n lodash.flatMapDepth = flatMapDepth;\n lodash.flatten = flatten;\n lodash.flattenDeep = flattenDeep;\n lodash.flattenDepth = flattenDepth;\n lodash.flip = flip;\n lodash.flow = flow;\n lodash.flowRight = flowRight;\n lodash.fromPairs = fromPairs;\n lodash.functions = functions;\n lodash.functionsIn = functionsIn;\n lodash.groupBy = groupBy;\n lodash.initial = initial;\n lodash.intersection = intersection;\n lodash.intersectionBy = intersectionBy;\n lodash.intersectionWith = intersectionWith;\n lodash.invert = invert;\n lodash.invertBy = invertBy;\n lodash.invokeMap = invokeMap;\n lodash.iteratee = iteratee;\n lodash.keyBy = keyBy;\n lodash.keys = keys;\n lodash.keysIn = keysIn;\n lodash.map = map;\n lodash.mapKeys = mapKeys;\n lodash.mapValues = mapValues;\n lodash.matches = matches;\n lodash.matchesProperty = matchesProperty;\n lodash.memoize = memoize;\n lodash.merge = merge;\n lodash.mergeWith = mergeWith;\n lodash.method = method;\n lodash.methodOf = methodOf;\n lodash.mixin = mixin;\n lodash.negate = negate;\n lodash.nthArg = nthArg;\n lodash.omit = omit;\n lodash.omitBy = omitBy;\n lodash.once = once;\n lodash.orderBy = orderBy;\n lodash.over = over;\n lodash.overArgs = overArgs;\n lodash.overEvery = overEvery;\n lodash.overSome = overSome;\n lodash.partial = partial;\n lodash.partialRight = partialRight;\n lodash.partition = partition;\n lodash.pick = pick;\n lodash.pickBy = pickBy;\n lodash.property = property;\n lodash.propertyOf = propertyOf;\n lodash.pull = pull;\n lodash.pullAll = pullAll;\n lodash.pullAllBy = pullAllBy;\n lodash.pullAllWith = pullAllWith;\n lodash.pullAt = pullAt;\n lodash.range = range;\n lodash.rangeRight = rangeRight;\n lodash.rearg = rearg;\n lodash.reject = reject;\n lodash.remove = remove;\n lodash.rest = rest;\n lodash.reverse = reverse;\n lodash.sampleSize = sampleSize;\n lodash.set = set;\n lodash.setWith = setWith;\n lodash.shuffle = shuffle;\n lodash.slice = slice;\n lodash.sortBy = sortBy;\n lodash.sortedUniq = sortedUniq;\n lodash.sortedUniqBy = sortedUniqBy;\n lodash.split = split;\n lodash.spread = spread;\n lodash.tail = tail;\n lodash.take = take;\n lodash.takeRight = takeRight;\n lodash.takeRightWhile = takeRightWhile;\n lodash.takeWhile = takeWhile;\n lodash.tap = tap;\n lodash.throttle = throttle;\n lodash.thru = thru;\n lodash.toArray = toArray;\n lodash.toPairs = toPairs;\n lodash.toPairsIn = toPairsIn;\n lodash.toPath = toPath;\n lodash.toPlainObject = toPlainObject;\n lodash.transform = transform;\n lodash.unary = unary;\n lodash.union = union;\n lodash.unionBy = unionBy;\n lodash.unionWith = unionWith;\n lodash.uniq = uniq;\n lodash.uniqBy = uniqBy;\n lodash.uniqWith = uniqWith;\n lodash.unset = unset;\n lodash.unzip = unzip;\n lodash.unzipWith = unzipWith;\n lodash.update = update;\n lodash.updateWith = updateWith;\n lodash.values = values;\n lodash.valuesIn = valuesIn;\n lodash.without = without;\n lodash.words = words;\n lodash.wrap = wrap;\n lodash.xor = xor;\n lodash.xorBy = xorBy;\n lodash.xorWith = xorWith;\n lodash.zip = zip;\n lodash.zipObject = zipObject;\n lodash.zipObjectDeep = zipObjectDeep;\n lodash.zipWith = zipWith;\n\n // Add aliases.\n lodash.entries = toPairs;\n lodash.entriesIn = toPairsIn;\n lodash.extend = assignIn;\n lodash.extendWith = assignInWith;\n\n // Add methods to `lodash.prototype`.\n mixin(lodash, lodash);\n\n /*------------------------------------------------------------------------*/\n\n // Add methods that return unwrapped values in chain sequences.\n lodash.add = add;\n lodash.attempt = attempt;\n lodash.camelCase = camelCase;\n lodash.capitalize = capitalize;\n lodash.ceil = ceil;\n lodash.clamp = clamp;\n lodash.clone = clone;\n lodash.cloneDeep = cloneDeep;\n lodash.cloneDeepWith = cloneDeepWith;\n lodash.cloneWith = cloneWith;\n lodash.conformsTo = conformsTo;\n lodash.deburr = deburr;\n lodash.defaultTo = defaultTo;\n lodash.divide = divide;\n lodash.endsWith = endsWith;\n lodash.eq = eq;\n lodash.escape = escape;\n lodash.escapeRegExp = escapeRegExp;\n lodash.every = every;\n lodash.find = find;\n lodash.findIndex = findIndex;\n lodash.findKey = findKey;\n lodash.findLast = findLast;\n lodash.findLastIndex = findLastIndex;\n lodash.findLastKey = findLastKey;\n lodash.floor = floor;\n lodash.forEach = forEach;\n lodash.forEachRight = forEachRight;\n lodash.forIn = forIn;\n lodash.forInRight = forInRight;\n lodash.forOwn = forOwn;\n lodash.forOwnRight = forOwnRight;\n lodash.get = get;\n lodash.gt = gt;\n lodash.gte = gte;\n lodash.has = has;\n lodash.hasIn = hasIn;\n lodash.head = head;\n lodash.identity = identity;\n lodash.includes = includes;\n lodash.indexOf = indexOf;\n lodash.inRange = inRange;\n lodash.invoke = invoke;\n lodash.isArguments = isArguments;\n lodash.isArray = isArray;\n lodash.isArrayBuffer = isArrayBuffer;\n lodash.isArrayLike = isArrayLike;\n lodash.isArrayLikeObject = isArrayLikeObject;\n lodash.isBoolean = isBoolean;\n lodash.isBuffer = isBuffer;\n lodash.isDate = isDate;\n lodash.isElement = isElement;\n lodash.isEmpty = isEmpty;\n lodash.isEqual = isEqual;\n lodash.isEqualWith = isEqualWith;\n lodash.isError = isError;\n lodash.isFinite = isFinite;\n lodash.isFunction = isFunction;\n lodash.isInteger = isInteger;\n lodash.isLength = isLength;\n lodash.isMap = isMap;\n lodash.isMatch = isMatch;\n lodash.isMatchWith = isMatchWith;\n lodash.isNaN = isNaN;\n lodash.isNative = isNative;\n lodash.isNil = isNil;\n lodash.isNull = isNull;\n lodash.isNumber = isNumber;\n lodash.isObject = isObject;\n lodash.isObjectLike = isObjectLike;\n lodash.isPlainObject = isPlainObject;\n lodash.isRegExp = isRegExp;\n lodash.isSafeInteger = isSafeInteger;\n lodash.isSet = isSet;\n lodash.isString = isString;\n lodash.isSymbol = isSymbol;\n lodash.isTypedArray = isTypedArray;\n lodash.isUndefined = isUndefined;\n lodash.isWeakMap = isWeakMap;\n lodash.isWeakSet = isWeakSet;\n lodash.join = join;\n lodash.kebabCase = kebabCase;\n lodash.last = last;\n lodash.lastIndexOf = lastIndexOf;\n lodash.lowerCase = lowerCase;\n lodash.lowerFirst = lowerFirst;\n lodash.lt = lt;\n lodash.lte = lte;\n lodash.max = max;\n lodash.maxBy = maxBy;\n lodash.mean = mean;\n lodash.meanBy = meanBy;\n lodash.min = min;\n lodash.minBy = minBy;\n lodash.stubArray = stubArray;\n lodash.stubFalse = stubFalse;\n lodash.stubObject = stubObject;\n lodash.stubString = stubString;\n lodash.stubTrue = stubTrue;\n lodash.multiply = multiply;\n lodash.nth = nth;\n lodash.noConflict = noConflict;\n lodash.noop = noop;\n lodash.now = now;\n lodash.pad = pad;\n lodash.padEnd = padEnd;\n lodash.padStart = padStart;\n lodash.parseInt = parseInt;\n lodash.random = random;\n lodash.reduce = reduce;\n lodash.reduceRight = reduceRight;\n lodash.repeat = repeat;\n lodash.replace = replace;\n lodash.result = result;\n lodash.round = round;\n lodash.runInContext = runInContext;\n lodash.sample = sample;\n lodash.size = size;\n lodash.snakeCase = snakeCase;\n lodash.some = some;\n lodash.sortedIndex = sortedIndex;\n lodash.sortedIndexBy = sortedIndexBy;\n lodash.sortedIndexOf = sortedIndexOf;\n lodash.sortedLastIndex = sortedLastIndex;\n lodash.sortedLastIndexBy = sortedLastIndexBy;\n lodash.sortedLastIndexOf = sortedLastIndexOf;\n lodash.startCase = startCase;\n lodash.startsWith = startsWith;\n lodash.subtract = subtract;\n lodash.sum = sum;\n lodash.sumBy = sumBy;\n lodash.template = template;\n lodash.times = times;\n lodash.toFinite = toFinite;\n lodash.toInteger = toInteger;\n lodash.toLength = toLength;\n lodash.toLower = toLower;\n lodash.toNumber = toNumber;\n lodash.toSafeInteger = toSafeInteger;\n lodash.toString = toString;\n lodash.toUpper = toUpper;\n lodash.trim = trim;\n lodash.trimEnd = trimEnd;\n lodash.trimStart = trimStart;\n lodash.truncate = truncate;\n lodash.unescape = unescape;\n lodash.uniqueId = uniqueId;\n lodash.upperCase = upperCase;\n lodash.upperFirst = upperFirst;\n\n // Add aliases.\n lodash.each = forEach;\n lodash.eachRight = forEachRight;\n lodash.first = head;\n\n mixin(lodash, (function() {\n var source = {};\n baseForOwn(lodash, function(func, methodName) {\n if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n source[methodName] = func;\n }\n });\n return source;\n }()), { 'chain': false });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * The semantic version number.\n *\n * @static\n * @memberOf _\n * @type {string}\n */\n lodash.VERSION = VERSION;\n\n // Assign default placeholders.\n arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n lodash[methodName].placeholder = lodash;\n });\n\n // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n arrayEach(['drop', 'take'], function(methodName, index) {\n LazyWrapper.prototype[methodName] = function(n) {\n n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n var result = (this.__filtered__ && !index)\n ? new LazyWrapper(this)\n : this.clone();\n\n if (result.__filtered__) {\n result.__takeCount__ = nativeMin(n, result.__takeCount__);\n } else {\n result.__views__.push({\n 'size': nativeMin(n, MAX_ARRAY_LENGTH),\n 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n });\n }\n return result;\n };\n\n LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n return this.reverse()[methodName](n).reverse();\n };\n });\n\n // Add `LazyWrapper` methods that accept an `iteratee` value.\n arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n var type = index + 1,\n isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n LazyWrapper.prototype[methodName] = function(iteratee) {\n var result = this.clone();\n result.__iteratees__.push({\n 'iteratee': getIteratee(iteratee, 3),\n 'type': type\n });\n result.__filtered__ = result.__filtered__ || isFilter;\n return result;\n };\n });\n\n // Add `LazyWrapper` methods for `_.head` and `_.last`.\n arrayEach(['head', 'last'], function(methodName, index) {\n var takeName = 'take' + (index ? 'Right' : '');\n\n LazyWrapper.prototype[methodName] = function() {\n return this[takeName](1).value()[0];\n };\n });\n\n // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n arrayEach(['initial', 'tail'], function(methodName, index) {\n var dropName = 'drop' + (index ? '' : 'Right');\n\n LazyWrapper.prototype[methodName] = function() {\n return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n };\n });\n\n LazyWrapper.prototype.compact = function() {\n return this.filter(identity);\n };\n\n LazyWrapper.prototype.find = function(predicate) {\n return this.filter(predicate).head();\n };\n\n LazyWrapper.prototype.findLast = function(predicate) {\n return this.reverse().find(predicate);\n };\n\n LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n if (typeof path == 'function') {\n return new LazyWrapper(this);\n }\n return this.map(function(value) {\n return baseInvoke(value, path, args);\n });\n });\n\n LazyWrapper.prototype.reject = function(predicate) {\n return this.filter(negate(getIteratee(predicate)));\n };\n\n LazyWrapper.prototype.slice = function(start, end) {\n start = toInteger(start);\n\n var result = this;\n if (result.__filtered__ && (start > 0 || end < 0)) {\n return new LazyWrapper(result);\n }\n if (start < 0) {\n result = result.takeRight(-start);\n } else if (start) {\n result = result.drop(start);\n }\n if (end !== undefined) {\n end = toInteger(end);\n result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n }\n return result;\n };\n\n LazyWrapper.prototype.takeRightWhile = function(predicate) {\n return this.reverse().takeWhile(predicate).reverse();\n };\n\n LazyWrapper.prototype.toArray = function() {\n return this.take(MAX_ARRAY_LENGTH);\n };\n\n // Add `LazyWrapper` methods to `lodash.prototype`.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n isTaker = /^(?:head|last)$/.test(methodName),\n lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n retUnwrapped = isTaker || /^find/.test(methodName);\n\n if (!lodashFunc) {\n return;\n }\n lodash.prototype[methodName] = function() {\n var value = this.__wrapped__,\n args = isTaker ? [1] : arguments,\n isLazy = value instanceof LazyWrapper,\n iteratee = args[0],\n useLazy = isLazy || isArray(value);\n\n var interceptor = function(value) {\n var result = lodashFunc.apply(lodash, arrayPush([value], args));\n return (isTaker && chainAll) ? result[0] : result;\n };\n\n if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n isLazy = useLazy = false;\n }\n var chainAll = this.__chain__,\n isHybrid = !!this.__actions__.length,\n isUnwrapped = retUnwrapped && !chainAll,\n onlyLazy = isLazy && !isHybrid;\n\n if (!retUnwrapped && useLazy) {\n value = onlyLazy ? value : new LazyWrapper(this);\n var result = func.apply(value, args);\n result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n return new LodashWrapper(result, chainAll);\n }\n if (isUnwrapped && onlyLazy) {\n return func.apply(this, args);\n }\n result = this.thru(interceptor);\n return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n };\n });\n\n // Add `Array` methods to `lodash.prototype`.\n arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n var func = arrayProto[methodName],\n chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n lodash.prototype[methodName] = function() {\n var args = arguments;\n if (retUnwrapped && !this.__chain__) {\n var value = this.value();\n return func.apply(isArray(value) ? value : [], args);\n }\n return this[chainName](function(value) {\n return func.apply(isArray(value) ? value : [], args);\n });\n };\n });\n\n // Map minified method names to their real names.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var lodashFunc = lodash[methodName];\n if (lodashFunc) {\n var key = lodashFunc.name + '';\n if (!hasOwnProperty.call(realNames, key)) {\n realNames[key] = [];\n }\n realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n }\n });\n\n realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n 'name': 'wrapper',\n 'func': undefined\n }];\n\n // Add methods to `LazyWrapper`.\n LazyWrapper.prototype.clone = lazyClone;\n LazyWrapper.prototype.reverse = lazyReverse;\n LazyWrapper.prototype.value = lazyValue;\n\n // Add chain sequence methods to the `lodash` wrapper.\n lodash.prototype.at = wrapperAt;\n lodash.prototype.chain = wrapperChain;\n lodash.prototype.commit = wrapperCommit;\n lodash.prototype.next = wrapperNext;\n lodash.prototype.plant = wrapperPlant;\n lodash.prototype.reverse = wrapperReverse;\n lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n // Add lazy aliases.\n lodash.prototype.first = lodash.prototype.head;\n\n if (symIterator) {\n lodash.prototype[symIterator] = wrapperToIterator;\n }\n return lodash;\n });\n\n /*--------------------------------------------------------------------------*/\n\n // Export lodash.\n var _ = runInContext();\n\n // Some AMD build optimizers, like r.js, check for condition patterns like:\n if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n // Expose Lodash on the global object to prevent errors when Lodash is\n // loaded by a script tag in the presence of an AMD loader.\n // See http://requirejs.org/docs/errors.html#mismatch for more details.\n // Use `_.noConflict` to remove Lodash from the global object.\n root._ = _;\n\n // Define as an anonymous module so, through path mapping, it can be\n // referenced as the \"underscore\" module.\n define(function() {\n return _;\n });\n }\n // Check for `exports` after `define` in case a build optimizer adds it.\n else if (freeModule) {\n // Export for Node.js.\n (freeModule.exports = _)._ = _;\n // Export for CommonJS support.\n freeExports._ = _;\n }\n else {\n // Export to the global object.\n root._ = _;\n }\n}.call(this));\n"],"sourceRoot":""}