mapping.js

'use strict';

/** Load other modules. */
var _ = require('lodash'),
    util = require('./util.js');

/** Module references. */
var createMap = util.createMap;

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

module.exports = {

  /** Used to map aliases to their real names. */
  'aliasToReal': createMap({
    'commit': 'wrapperCommit',
    'each': 'forEach',
    'eachRight': 'forEachRight',
    'extend': 'assignIn',
    'extendWith': 'assignInWith',
    'next': 'wrapperNext',
    'plant': 'wrapperPlant',
    'run': 'wrapperValue',
    'toIterator': 'wrapperToIterator',
    'toJSON': 'wrapperValue',
    'valueOf': 'wrapperValue',
    'value': 'wrapperValue'
  }),

  /** Used to track the category of identifiers. */
  'category': createMap({
    'Array': [
      'chunk',
      'compact',
      'concat',
      'difference',
      'differenceBy',
      'differenceWith',
      'drop',
      'dropRight',
      'dropRightWhile',
      'dropWhile',
      'fill',
      'findIndex',
      'findLastIndex',
      'flatMap',
      'flatten',
      'flattenDeep',
      'fromPairs',
      'head',
      'indexOf',
      'initial',
      'intersection',
      'intersectionBy',
      'intersectionWith',
      'join',
      'last',
      'lastIndexOf',
      'pull',
      'pullAll',
      'pullAllBy',
      'pullAt',
      'remove',
      'reverse',
      'slice',
      'sortedIndex',
      'sortedIndexBy',
      'sortedIndexOf',
      'sortedLastIndex',
      'sortedLastIndexBy',
      'sortedLastIndexOf',
      'sortedUniq',
      'sortedUniqBy',
      'tail',
      'take',
      'takeRight',
      'takeRightWhile',
      'takeWhile',
      'union',
      'unionBy',
      'unionWith',
      'uniq',
      'uniqBy',
      'uniqWith',
      'unzip',
      'unzipWith',
      'without',
      'xor',
      'xorBy',
      'xorWith',
      'zip',
      'zipObject',
      'zipWith'
    ],
    'Chain': [
      'chain',
      'lodash',
      'tap',
      'thru',
      'wrapperAt',
      'wrapperChain',
      'wrapperCommit',
      'wrapperFlatMap',
      'wrapperNext',
      'wrapperPlant',
      'wrapperReverse',
      'wrapperToIterator',
      'wrapperValue'
    ],
    'Collection': [
      'at',
      'countBy',
      'every',
      'filter',
      'find',
      'findLast',
      'forEach',
      'forEachRight',
      'groupBy',
      'includes',
      'invokeMap',
      'keyBy',
      'map',
      'orderBy',
      'partition',
      'reduce',
      'reduceRight',
      'reject',
      'sample',
      'sampleSize',
      'shuffle',
      'size',
      'some',
      'sortBy'
    ],
    'Date': [
      'now'
    ],
    'Function': [
      'after',
      'ary',
      'before',
      'bind',
      'bindAll',
      'bindKey',
      'curry',
      'curryRight',
      'debounce',
      'defer',
      'delay',
      'flip',
      'memoize',
      'negate',
      'once',
      'overArgs',
      'partial',
      'partialRight',
      'rearg',
      'rest',
      'spread',
      'throttle',
      'unary',
      'wrap'
    ],
    'Lang': [
      'clone',
      'cloneDeep',
      'cloneDeepWith',
      'cloneWith',
      'eq',
      'gt',
      'gte',
      'isArguments',
      'isArray',
      'isArrayLike',
      'isArrayLikeObject',
      'isBoolean',
      'isDate',
      'isElement',
      'isEmpty',
      'isEqual',
      'isEqualWith',
      'isError',
      'isFinite',
      'isFunction',
      'isInteger',
      'isLength',
      'isMatch',
      'isMatchWith',
      'isNaN',
      'isNative',
      'isNil',
      'isNull',
      'isNumber',
      'isObject',
      'isObjectLike',
      'isPlainObject',
      'isRegExp',
      'isSafeInteger',
      'isString',
      'isTypedArray',
      'isUndefined',
      'lt',
      'lte',
      'toArray',
      'toInteger',
      'toLength',
      'toNumber',
      'toPlainObject',
      'toSafeInteger',
      'toString'
    ],
    'Math': [
      'add',
      'ceil',
      'floor',
      'max',
      'maxBy',
      'mean',
      'min',
      'minBy',
      'round',
      'subtract',
      'sum',
      'sumBy'
    ],
    'Number': [
      'clamp',
      'random',
      'inRange'
    ],
    'Object': [
      'assign',
      'assignIn',
      'assignInWith',
      'assignWith',
      'create',
      'defaults',
      'defaultsDeep',
      'findKey',
      'findLastKey',
      'forIn',
      'forInRight',
      'forOwn',
      'forOwnRight',
      'functions',
      'functionsIn',
      'get',
      'has',
      'hasIn',
      'invert',
      'invoke',
      'keys',
      'keysIn',
      'mapKeys',
      'mapValues',
      'merge',
      'mergeWith',
      'omit',
      'omitBy',
      'pick',
      'pickBy',
      'result',
      'set',
      'setWith',
      'toPairs',
      'toPairsIn',
      'transform',
      'unset',
      'values',
      'valuesIn'
    ],
    'String': [
      'camelCase',
      'capitalize',
      'deburr',
      'endsWith',
      'escape',
      'escapeRegExp',
      'kebabCase',
      'lowerCase',
      'lowerFirst',
      'pad',
      'padEnd',
      'padStart',
      'parseInt',
      'repeat',
      'replace',
      'snakeCase',
      'split',
      'startCase',
      'startsWith',
      'template',
      'templateSettings',
      'toLower',
      'toUpper',
      'trim',
      'trimEnd',
      'trimStart',
      'truncate',
      'unescape',
      'upperCase',
      'upperFirst',
      'words'
    ],
    'Utility': [
      'attempt',
      'conforms',
      'constant',
      'flow',
      'flowRight',
      'identity',
      'iteratee',
      'matches',
      'matchesProperty',
      'method',
      'methodOf',
      'mixin',
      'noConflict',
      'noop',
      'nthArg',
      'over',
      'overEvery',
      'overSome',
      'property',
      'propertyOf',
      'range',
      'rangeRight',
      'runInContext',
      'times',
      'toPath',
      'uniqueId'
    ]
  }),

  /* Used to map categories to their dependency name. */
  'categoryToDepName': createMap({
    'Array': 'array',
    'Chain': 'chain',
    'Collection': 'collection',
    'Date': 'date',
    'Function': 'func',
    'Lang': 'lang',
    'Math': 'math',
    'Number': 'number',
    'Object': 'object',
    'String': 'string',
    'Utility': 'utility'
  }),

  /* Used to track dependencies for chaining */
  'chainDep': createMap({
    'funcDep': [
      'arrayEach', 'arrayPush', 'baseForOwn', 'baseInvoke', 'chain',
      'createHybridWrapper', 'getIteratee', 'identity', 'isArray', 'last',
      'lazyClone', 'lazyReverse', 'lazyValue', 'LazyWrapper', 'LodashWrapper',
      'mixin', 'rest', 'tap', 'thru', 'toInteger', 'wrapperAt', 'wrapperChain',
      'wrapperCommit', 'wrapperFlatMap', 'wrapperNext', 'wrapperPlant',
      'wrapperReverse', 'wrapperToIterator', 'wrapperValue'
    ],
    'objDep': ['realNames'],
    'varDep': ['root']
  }),

  /* Used to force referencing identifers by their alias. */
  'forceAlias': createMap({
    'wrapperAt': 'at',
    'wrapperCommit': 'commit',
    'wrapperFlatMap': 'flatMap',
    'wrapperNext': 'next',
    'wrapperPlant': 'plant',
    'wrapperReverse': 'reverse',
    'wrapperToIterator': 'toIterator',
    'wrapperValue': 'value'
  }),

  /* Used to force inlining of uninlinables per identifier. */
  'forceInline': createMap({
    'baseEach': ['baseFor'],
    'baseIteratee': ['baseGet', 'baseIsMatch', 'baseMatches', 'baseMatchesProperty'],
    'getNative': ['isNative'],
    'keys': ['baseHas', 'baseKeys', 'indexKeys', 'isArrayLike', 'isIndex', 'isPrototype'],
    'keysIn': ['baseKeysIn', 'indexKeys', 'isIndex', 'isPrototype'],
    'template': ['attempt', 'isError'],
    'templateSettings': ['reEscape', 'reEvaluate'],
    'toInteger': ['baseTrim', 'isFunction', 'isObject', 'isString', 'toNumber', 'trimmedEndIndex', 'trimmedStartIndex'],
    'toNumber': ['baseTrim', 'isFunction', 'isObject', 'isString', 'trimmedEndIndex', 'trimmedStartIndex'],
    'baseToPath': ['isArray', 'stringToPath']
  }),

  /** Used to track function dependencies. */
  'funcDep': createMap({

    // Dependencies of variables.
    'Map': ['getNative'],
    'Set': ['getNative'],
    'WeakMap': ['getNative'],
    'nativeCreate': ['getNative'],
    'root': ['checkGlobal'],

    // Dependencies of lodash properties.
    'templateSettings': ['escape'],

    // Dependencies of the main module.
    'main': ['lodash'],

    // Dependencies of assoc functions.
    'assocDelete': ['assocIndexOf'],
    'assocGet': ['assocIndexOf'],
    'assocHas': ['assocIndexOf'],
    'assocSet': ['assocIndexOf'],
    'assocIndexOf': ['eq'],

    // Dependencies of hash functions.
    'Hash': [],
    'hashDelete': ['hashHas'],
    'hashGet': [],
    'hashHas': [],
    'hashSet': [],

    // Dependencies of Lazy wrapper functions.
    'LazyWrapper': ['baseCreate', 'baseLodash'],
    'lazyClone': ['copyArray', 'LazyWrapper'],
    'lazyReverse': ['LazyWrapper'],
    'lazyValue': ['baseWrapperValue', 'getView', 'isArray'],

    // Dependencies of lodash wrapper functions.
    'LodashWrapper': ['baseCreate', 'baseLodash'],
    'wrapperAt': ['baseAt', 'baseFlatten', 'isIndex', 'LazyWrapper', 'LodashWrapper', 'rest', 'thru'],
    'wrapperChain': ['chain'],
    'wrapperClone': ['copyArray', 'LazyWrapper', 'LodashWrapper'],
    'wrapperCommit': ['LodashWrapper'],
    'wrapperFlatMap': [],
    'wrapperNext': ['toArray'],
    'wrapperPlant': ['baseLodash', 'wrapperClone'],
    'wrapperReverse': ['LazyWrapper', 'LodashWrapper', 'reverse', 'thru'],
    'wrapperToIterator': [],
    'wrapperValue': ['baseWrapperValue'],

    // Dependencies of `MapCache` functions.
    'MapCache': ['mapClear', 'mapDelete', 'mapGet', 'mapHas', 'mapSet'],
    'mapClear': ['Hash'],
    'mapDelete': ['assocDelete', 'hashDelete', 'isKeyable'],
    'mapGet': ['assocGet', 'hashGet', 'isKeyable'],
    'mapHas': ['assocHas', 'hashHas', 'isKeyable'],
    'mapSet': ['assocSet', 'hashSet', 'isKeyable'],

    // Dependencies of `SetCache` functions.
    'SetCache': ['cachePush', 'MapCache'],
    'cacheHas': ['isKeyable'],
    'cachePush': ['isKeyable'],

    // Dependencies of `Stack` functions.
    'Stack': ['stackClear', 'stackDelete', 'stackGet', 'stackHas', 'stackSet'],
    'stackClear': [],
    'stackDelete': ['assocDelete'],
    'stackGet': ['assocGet'],
    'stackHas': ['assocHas'],
    'stackSet': ['assocSet', 'MapCache'],

    // Dependencies of lodash methods.
    'add': [],
    'after': ['toInteger'],
    'ary': ['createWrapper'],
    'assign': ['copyObject', 'createAssigner', 'keys'],
    'assignIn': ['copyObject', 'createAssigner', 'keysIn'],
    'assignInWith': ['copyObjectWith', 'createAssigner', 'keysIn'],
    'assignWith': ['copyObjectWith', 'createAssigner', 'keys'],
    'at': ['baseAt', 'baseFlatten', 'rest'],
    'attempt': ['apply', 'isError', 'rest'],
    'before': ['toInteger'],
    'bind': ['createWrapper', 'lodash', 'rest', 'replaceHolders'],
    'bindAll': ['arrayEach', 'baseFlatten', 'bind', 'rest'],
    'bindKey': [ 'createWrapper', 'lodash', 'rest', 'replaceHolders'],
    'camelCase': ['capitalize', 'createCompounder'],
    'capitalize': ['toString', 'upperFirst'],
    'ceil': ['createRound'],
    'chain': ['lodash'],
    'chunk': ['baseSlice', 'toInteger'],
    'clamp': ['toNumber'],
    'clone': ['baseClone'],
    'cloneDeep': ['baseClone'],
    'cloneDeepWith': ['baseClone'],
    'cloneWith': ['baseClone'],
    'compact': [],
    'concat': ['arrayConcat', 'baseFlatten', 'isArray', 'rest'],
    'conforms': ['baseClone', 'baseConforms'],
    'constant': [],
    'countBy': ['createAggregator'],
    'create': ['baseAssign', 'baseCreate'],
    'curry': ['createWrapper', 'lodash'],
    'curryRight': ['createWrapper', 'lodash'],
    'debounce': ['isObject', 'now', 'toNumber'],
    'deburr': ['toString', 'deburrLetter'],
    'defaults': ['apply', 'assignInDefaults', 'assignInWith', 'rest'],
    'defaultsDeep': ['apply', 'mergeDefaults', 'mergeWith', 'rest'],
    'defer': ['baseDelay', 'rest'],
    'delay': ['baseDelay', 'rest', 'toNumber'],
    'difference': ['baseDifference', 'baseFlatten', 'isArrayLikeObject', 'rest'],
    'differenceBy': ['baseDifference', 'baseFlatten', 'getIteratee', 'isArrayLikeObject', 'last', 'rest'],
    'differenceWith': ['baseDifference', 'baseFlatten', 'isArrayLikeObject', 'last', 'rest'],
    'drop': ['baseSlice'],
    'dropRight': ['baseSlice', 'toInteger'],
    'dropRightWhile': ['baseWhile', 'getIteratee'],
    'dropWhile': ['baseWhile', 'getIteratee'],
    'endsWith': ['clamp', 'toString', 'toInteger'],
    'eq': [],
    'escape': ['toString', 'escapeHtmlChar'],
    'escapeRegExp': ['toString'],
    'every': ['arrayEvery', 'baseEvery', 'getIteratee', 'isArray', 'isIterateeCall'],
    'fill': ['baseFill', 'isIterateeCall'],
    'filter': ['arrayFilter', 'baseFilter', 'getIteratee', 'isArray'],
    'find': ['baseEach', 'baseFind', 'baseFindIndex', 'getIteratee', 'isArray'],
    'findIndex': ['baseFindIndex', 'getIteratee'],
    'findLastIndex': ['baseFindIndex', 'getIteratee'],
    'findKey': ['baseFind', 'baseForOwn', 'getIteratee'],
    'findLast': ['baseEachRight', 'baseFind', 'baseFindIndex', 'getIteratee', 'isArray'],
    'findLastKey': ['baseFind', 'baseForOwnRight', 'getIteratee'],
    'flatMap': ['arrayMap', 'baseFlatten', 'getIteratee'],
    'flatten': ['baseFlatten'],
    'flattenDeep': ['baseFlatten'],
    'flip': ['createWrapper'],
    'floor': ['createRound'],
    'flow': ['createFlow'],
    'flowRight': ['createFlow'],
    'forEach': ['arrayEach', 'baseEach', 'toFunction', 'isArray'],
    'forEachRight': ['arrayEachRight', 'baseEachRight', 'toFunction', 'isArray'],
    'forIn': ['baseFor', 'toFunction', 'keysIn'],
    'forInRight': ['baseForRight', 'toFunction', 'keysIn'],
    'forOwn': ['baseForOwn', 'toFunction'],
    'forOwnRight': ['baseForOwnRight', 'toFunction'],
    'fromPairs': ['baseSet'],
    'functions': ['baseFunctions', 'keys'],
    'functionsIn': ['baseFunctions', 'keysIn'],
    'get': ['baseGet'],
    'groupBy': ['createAggregator'],
    'gt': [],
    'gte': [],
    'has': ['baseHas', 'hasPath'],
    'hasIn': ['baseHasIn', 'hasPath'],
    'head': [],
    'identity': [],
    'includes': ['baseIndexOf', 'isArrayLike', 'isString', 'toInteger', 'values'],
    'indexOf': ['baseIndexOf', 'toInteger'],
    'initial': ['dropRight'],
    'inRange': ['toNumber'],
    'intersection': ['arrayMap', 'baseIntersection', 'rest', 'toArrayLikeObject'],
    'intersectionBy': ['arrayMap', 'baseIntersection', 'getIteratee', 'last', 'rest', 'toArrayLikeObject'],
    'intersectionWith': ['arrayMap', 'baseIntersection', 'last', 'rest', 'toArrayLikeObject'],
    'invert': ['arrayReduce', 'keys'],
    'invokeMap': ['apply', 'baseEach', 'baseInvoke', 'isKey', 'isArrayLike', 'rest'],
    'invoke': ['baseInvoke', 'rest'],
    'isArguments': ['isArrayLikeObject'],
    'isArray': [],
    'isBoolean': ['isObjectLike'],
    'isDate': ['isObjectLike'],
    'isElement': ['isObjectLike', 'isPlainObject'],
    'isEmpty': ['isFunction', 'isObjectLike', 'keys', 'size'],
    'isEqual': ['baseIsEqual'],
    'isEqualWith': ['baseIsEqual'],
    'isError': ['isObjectLike'],
    'isFinite': [],
    'isFunction': ['isObject'],
    'isInteger': ['toInteger'],
    'isLength': [],
    'isMatch': ['baseIsMatch', 'getMatchData'],
    'isMatchWith': ['baseIsMatch', 'getMatchData'],
    'isNaN': ['isNumber'],
    'isNative': ['isFunction', 'isHostObject', 'isObjectLike'],
    'isNil': [],
    'isNull': [],
    'isNumber': ['isObjectLike'],
    'isObject': [],
    'isObjectLike': [],
    'isPlainObject': ['isHostObject', 'isObjectLike'],
    'isRegExp': ['isObject'],
    'isSafeInteger': ['isInteger'],
    'isString': ['isArray', 'isObjectLike'],
    'isTypedArray': ['isLength', 'isObjectLike'],
    'isUndefined': [],
    'iteratee': ['baseIteratee', 'isArray', 'isObjectLike', 'matches'],
    'join': [],
    'kebabCase': ['createCompounder'],
    'keyBy': ['createAggregator'],
    'keys': ['baseHas', 'baseKeys', 'indexKeys', 'isArrayLike', 'isIndex', 'isPrototype'],
    'keysIn': ['baseKeysIn', 'indexKeys', 'isIndex', 'isPrototype'],
    'last': [],
    'lastIndexOf': ['indexOfNaN', 'toInteger'],
    'lodash': ['baseLodash', 'isArray', 'isObjectLike', 'LazyWrapper', 'LodashWrapper', 'wrapperClone'],
    'lowerCase': ['createCompounder'],
    'lowerFirst': ['createCaseFirst'],
    'lt': [],
    'lte': [],
    'map': ['arrayMap', 'baseMap', 'getIteratee', 'isArray'],
    'mapKeys': ['baseForOwn', 'getIteratee'],
    'mapValues': ['baseForOwn', 'getIteratee'],
    'matches': ['baseClone', 'baseMatches'],
    'matchesProperty': ['baseClone', 'baseMatchesProperty'],
    'method': ['baseInvoke', 'rest'],
    'methodOf': ['baseInvoke', 'rest'],
    'max': ['baseExtremum', 'gt', 'identity'],
    'maxBy': ['baseExtremum', 'getIteratee', 'gt'],
    'mean': ['sum'],
    'memoize': ['MapCache'],
    'merge': ['baseMerge', 'createAssigner'],
    'mergeWith': ['baseMerge', 'createAssigner'],
    'min': ['baseExtremum', 'identity', 'lt'],
    'minBy': ['baseExtremum', 'getIteratee', 'lt'],
    'mixin': ['arrayEach', 'arrayPush', 'baseFunctions', 'copyArray', 'isFunction', 'isObject', 'keys', 'lodash'],
    'negate': [],
    'noConflict': [],
    'noop': [],
    'now': [],
    'nthArg': ['toInteger'],
    'omit': ['arrayMap', 'baseDifference', 'baseFlatten', 'keysIn', 'basePick', 'rest'],
    'omitBy': ['basePickBy', 'getIteratee'],
    'once': ['before'],
    'orderBy': ['baseOrderBy', 'isArray'],
    'over': ['arrayMap', 'createOver'],
    'overArgs': ['apply', 'arrayMap', 'baseFlatten', 'getIteratee', 'rest'],
    'overEvery': ['arrayEvery', 'createOver'],
    'overSome': ['arraySome', 'createOver'],
    'pad': ['toString', 'createPadding', 'stringSize', 'toInteger'],
    'padEnd': ['toString', 'createPadding'],
    'padStart': ['toString', 'createPadding'],
    'parseInt': ['baseTrim', 'toString'],
    'partial': ['createWrapper', 'lodash', 'rest', 'replaceHolders'],
    'partialRight': ['createWrapper', 'lodash', 'rest', 'replaceHolders'],
    'partition': ['createAggregator'],
    'pick': ['baseFlatten', 'basePick', 'rest'],
    'pickBy': ['basePickBy', 'getIteratee'],
    'property': ['baseProperty', 'basePropertyDeep', 'isKey'],
    'propertyOf': ['baseGet'],
    'pull': ['pullAll', 'rest'],
    'pullAll': ['basePullAll'],
    'pullAllBy': ['basePullAllBy', 'getIteratee'],
    'pullAt': ['arrayMap', 'baseAt', 'baseFlatten', 'basePullAt', 'compareAscending', 'rest'],
    'random': ['baseRandom', 'isIterateeCall', 'toNumber'],
    'range': ['baseRange', 'isIterateeCall'],
    'rangeRight': ['baseRange', 'isIterateeCall'],
    'rearg': ['baseFlatten', 'createWrapper', 'rest'],
    'reduce': ['arrayReduce', 'baseEach', 'baseReduce', 'getIteratee', 'isArray'],
    'reduceRight': ['arrayReduceRight', 'baseEachRight', 'baseReduce', 'getIteratee', 'isArray'],
    'reject': ['arrayFilter', 'baseFilter', 'getIteratee', 'isArray'],
    'remove': ['basePullAt', 'getIteratee'],
    'repeat': ['toString', 'toInteger'],
    'replace': ['toString'],
    'rest': ['apply', 'toInteger'],
    'result': ['get', 'isFunction', 'isKey', 'parent', 'baseToPath'],
    'reverse': [],
    'round': ['createRound'],
    'runInContext': ['defaults', 'pick'],
    'sample': ['baseRandom', 'isArrayLike', 'values'],
    'sampleSize': ['baseRandom', 'clamp', 'toArray', 'toInteger'],
    'set': ['baseSet'],
    'setWith': ['baseSet'],
    'shuffle': ['sampleSize'],
    'size': ['isArrayLike', 'isString', 'keys', 'stringSize'],
    'slice': ['baseSlice', 'isIterateeCall'],
    'snakeCase': ['createCompounder'],
    'some': ['arraySome', 'baseSome', 'getIteratee', 'isArray', 'isIterateeCall'],
    'sortBy': ['baseFlatten', 'baseOrderBy', 'isIterateeCall', 'rest'],
    'sortedIndex': ['baseSortedIndex'],
    'sortedIndexBy': ['baseSortedIndexBy', 'getIteratee'],
    'sortedIndexOf': ['baseSortedIndex', 'eq'],
    'sortedLastIndex': ['baseSortedIndex'],
    'sortedLastIndexBy': ['baseSortedIndexBy', 'getIteratee'],
    'sortedLastIndexOf': ['baseSortedIndex', 'eq'],
    'sortedUniq': ['baseSortedUniq'],
    'sortedUniqBy': ['baseSortedUniqBy', 'getIteratee'],
    'split': ['toString'],
    'spread': ['apply'],
    'startCase': ['capitalize', 'createCompounder'],
    'startsWith': ['clamp', 'toString', 'toInteger'],
    'subtract': [],
    'sum': ['baseSum', 'identity'],
    'sumBy': ['baseSum', 'getIteratee'],
    'tail': ['drop'],
    'take': ['baseSlice'],
    'takeRight': ['baseSlice', 'toInteger'],
    'takeRightWhile': ['baseWhile', 'getIteratee'],
    'takeWhile': ['baseWhile', 'getIteratee'],
    'tap': [],
    'template': ['attempt', 'toString', 'baseValues', 'escapeStringChar', 'assignInDefaults', 'assignInWith', 'isError', 'isIterateeCall', 'keys'],
    'throttle': ['debounce', 'isObject'],
    'thru': [],
    'times': ['baseTimes', 'toFunction', 'toInteger'],
    'toArray': ['copyArray', 'getTag', 'isArrayLike', 'isString', 'iteratorToArray', 'mapToArray', 'setToArray', 'stringToArray', 'values'],
    'toInteger': ['toNumber'],
    'toLength': ['clamp', 'toInteger'],
    'toLower': ['toString'],
    'toNumber': ['baseTrim', 'isFunction', 'isObject', 'isString'],
    'toPairs': ['baseToPairs', 'keys'],
    'toPairsIn': ['baseToPairs', 'keysIn'],
    'toPath': ['arrayMap', 'isArray', 'stringToPath'],
    'toPlainObject': ['copyObject', 'keysIn'],
    'toSafeInteger': ['clamp', 'toInteger'],
    'toString': [],
    'toUpper': ['toString'],
    'transform': ['arrayEach', 'baseCreate', 'baseForOwn', 'getIteratee', 'isArray', 'isFunction', 'isObject', 'isTypedArray'],
    'trim': ['baseTrim', 'toString', 'charsEndIndex', 'charsStartIndex', 'stringToArray'],
    'trimEnd': ['toString', 'charsEndIndex', 'stringToArray', 'trimmedEndIndex'],
    'trimStart': ['toString', 'charsStartIndex', 'stringToArray', 'trimmedStartIndex'],
    'truncate': ['toString', 'isObject', 'isRegExp', 'stringSize', 'stringToArray', 'toInteger'],
    'unary': ['ary'],
    'unescape': ['toString', 'unescapeHtmlChar'],
    'union': ['baseFlatten', 'baseUniq', 'rest'],
    'unionBy': ['baseFlatten', 'baseUniq', 'getIteratee', 'isArrayLikeObject', 'last', 'rest'],
    'unionWith': ['baseFlatten', 'baseUniq', 'isArrayLikeObject', 'last', 'rest'],
    'uniq': ['baseUniq'],
    'uniqBy': ['baseUniq', 'getIteratee'],
    'uniqWith': ['baseUniq'],
    'uniqueId': ['toString'],
    'unset': ['baseUnset'],
    'unzip': ['arrayMap', 'arrayFilter', 'baseProperty', 'baseTimes', 'isArrayLikeObject'],
    'unzipWith': ['arrayMap', 'arrayReduce', 'unzip'],
    'upperCase': ['createCompounder'],
    'upperFirst': ['createCaseFirst'],
    'values': ['baseValues', 'keys'],
    'valuesIn': ['baseValues', 'keysIn'],
    'without': ['baseDifference', 'isArrayLikeObject', 'rest'],
    'words': ['toString'],
    'wrap': ['identity', 'partial'],
    'xor': ['arrayFilter', 'baseXor', 'isArrayLikeObject', 'rest'],
    'xorBy': ['arrayFilter', 'baseXor', 'getIteratee', 'isArrayLikeObject', 'last', 'rest'],
    'xorWith': ['arrayFilter', 'baseXor', 'isArrayLikeObject', 'last', 'rest'],
    'zip': ['rest', 'unzip'],
    'zipObject': ['baseSet'],
    'zipWith': ['rest', 'unzipWith'],

    // Dependencies of private functions.
    'addMapEntry': [],
    'addSetEntry': [],
    'apply': [],
    'arrayConcat': [],
    'arrayEach': [],
    'arrayEachRight': [],
    'arrayEvery': [],
    'arrayFilter': [],
    'arrayIncludes': ['baseIndexOf'],
    'arrayIncludesWith': [],
    'arrayMap': [],
    'arrayPush': [],
    'arrayReduce': [],
    'arrayReduceRight': [],
    'arraySome': [],
    'assignInDefaults': ['eq'],
    'assignMergeValue': ['eq'],
    'assignValue': ['eq'],
    'baseAssign': ['copyObject', 'keys'],
    'baseAt': ['get'],
    'baseClone': ['assignValue', 'copyArray', 'copySymbols', 'arrayEach', 'baseAssign', 'baseForOwn', 'getTag', 'initCloneArray', 'initCloneByTag', 'initCloneObject', 'isArray', 'isHostObject', 'isObject', 'Stack'],
    'baseConforms': ['keysIn'],
    'baseCreate': ['isObject'],
    'baseDelay': [],
    'baseDifference': ['arrayIncludes', 'arrayIncludesWith', 'arrayMap', 'baseUnary', 'cacheHas', 'SetCache'],
    'baseEach': ['baseForOwn', 'createBaseEach'],
    'baseEachRight': ['baseForOwnRight', 'createBaseEach'],
    'baseEvery': ['baseEach'],
    'baseExtremum': [],
    'baseFill': ['toInteger', 'toLength'],
    'baseFilter': ['baseEach'],
    'baseFind': [],
    'baseFindIndex': [],
    'baseFlatten': ['arrayPush', 'isArguments', 'isArray', 'isArrayLikeObject', 'Stack'],
    'baseFor': ['createBaseFor'],
    'baseForIn': ['baseFor', 'keysIn'],
    'baseForOwn': ['baseFor', 'keys'],
    'baseForOwnRight': ['baseForRight', 'keys'],
    'baseForRight': ['createBaseFor'],
    'baseFunctions': ['arrayFilter', 'isFunction'],
    'baseGet': ['isKey', 'baseToPath'],
    'baseHas': [],
    'baseHasIn': [],
    'baseIndexOf': ['indexOfNaN'],
    'baseIntersection': ['arrayIncludes', 'arrayIncludesWith', 'arrayMap', 'baseUnary', 'cacheHas', 'SetCache'],
    'baseInvoke': ['apply', 'isKey', 'last', 'parent', 'baseToPath'],
    'baseIsEqual': ['baseIsEqualDeep', 'isObject', 'isObjectLike'],
    'baseIsEqualDeep': ['equalArrays', 'equalByTag', 'equalObjects', 'getTag', 'isArray', 'isHostObject', 'isTypedArray', 'Stack'],
    'baseIsFunction': [],
    'baseIsMatch': ['baseIsEqual', 'Stack'],
    'baseIteratee': ['baseMatches', 'baseMatchesProperty', 'identity', 'isArray', 'property'],
    'baseKeys': [],
    'baseKeysIn': ['iteratorToArray'],
    'baseLodash': [],
    'baseMap': ['baseEach', 'isArrayLike'],
    'baseMatches': ['baseIsMatch', 'getMatchData'],
    'baseMatchesProperty': ['baseIsEqual', 'hasIn', 'get'],
    'baseMerge': ['arrayEach', 'assignMergeValue', 'baseMergeDeep', 'isArray', 'isObject', 'isTypedArray', 'keysIn', 'Stack'],
    'baseMergeDeep': ['assignMergeValue', 'baseClone', 'copyArray', 'isArguments', 'isArray', 'isArrayLikeObject', 'isFunction', 'isObject', 'isPlainObject', 'isTypedArray', 'toPlainObject'],
    'baseOrderBy': ['arrayMap', 'baseMap', 'baseSortBy', 'compareMultiple', 'getIteratee'],
    'basePick': ['arrayReduce'],
    'basePickBy': ['baseForIn'],
    'baseProperty': [],
    'basePropertyDeep': ['baseGet'],
    'basePullAll': ['basePullAllBy'],
    'basePullAllBy': ['arrayMap', 'baseIndexOf'],
    'basePullAt': ['isIndex', 'isKey', 'last', 'parent', 'baseToPath'],
    'baseRandom': [],
    'baseRange': ['toNumber'],
    'baseReduce': [],
    'baseSet': ['assignValue', 'isIndex', 'isKey', 'isObject', 'baseToPath'],
    'baseSetData': ['identity'],
    'baseSlice': ['toInteger'],
    'baseSome': ['baseEach'],
    'baseSortBy': [],
    'baseSortedIndex': ['baseSortedIndexBy', 'identity'],
    'baseSortedIndexBy': [],
    'baseSortedUniq': ['baseSortedUniqBy'],
    'baseSortedUniqBy': ['eq'],
    'baseSum': [],
    'baseTimes': [],
    'baseToPairs': ['arrayMap'],
    'baseToPath': ['isArray', 'stringToPath'],
    'baseTrim': ['trimmedEndIndex', 'trimmedStartIndex'],
    'baseUnary': [],
    'baseUniq': ['arrayIncludes', 'arrayIncludesWith', 'cacheHas', 'createSet', 'SetCache', 'setToArray'],
    'baseUnset': ['baseToPath', 'has', 'isKey', 'last', 'parent'],
    'baseValues': ['arrayMap'],
    'baseWhile': ['baseSlice'],
    'baseWrapperValue': ['arrayPush', 'arrayReduce', 'LazyWrapper'],
    'baseXor': ['arrayPush', 'baseDifference', 'baseUniq'],
    'charAtCallback': [],
    'charsStartIndex': ['baseIndexOf'],
    'charsEndIndex': ['baseIndexOf'],
    'checkGlobal': [],
    'cloneBuffer': [],
    'cloneMap': ['addMapEntry', 'arrayReduce', 'mapToArray'],
    'cloneRegExp': [],
    'cloneSet': ['addSetEntry', 'arrayReduce', 'setToArray'],
    'cloneSymbol': [],
    'cloneTypedArray': ['cloneBuffer'],
    'compareAscending': [],
    'compareMultiple': ['compareAscending'],
    'composeArgs': [],
    'composeArgsRight': [],
    'copyArray': [],
    'copyObject': ['copyObjectWith'],
    'copyObjectWith': ['assignValue'],
    'copySymbols': ['copyObject', 'getSymbols'],
    'createAggregator': ['baseEach', 'getIteratee', 'isArray'],
    'createAssigner': ['isIterateeCall', 'rest'],
    'createBaseEach': ['isArrayLike'],
    'createBaseFor': [],
    'createBaseWrapper': ['createCtorWrapper'],
    'createCaseFirst': ['stringToArray', 'toString'],
    'createCompounder': ['arrayReduce', 'deburr', 'words'],
    'createCtorWrapper': ['baseCreate', 'isObject'],
    'createCurryWrapper': ['apply', 'createCtorWrapper', 'createHybridWrapper', 'createRecurryWrapper', 'replaceHolders'],
    'createFlow': ['baseFlatten', 'getData', 'getFuncName', 'isArray', 'isLaziable', 'LodashWrapper', 'rest'],
    'createHybridWrapper': ['composeArgs', 'composeArgsRight', 'createCtorWrapper', 'createRecurryWrapper', 'reorder', 'replaceHolders'],
    'createOver': ['apply', 'arrayMap', 'baseFlatten', 'getIteratee', 'rest'],
    'createPadding': ['repeat', 'stringSize', 'stringToArray', 'toInteger'],
    'createPartialWrapper': ['apply', 'createCtorWrapper'],
    'createRecurryWrapper': ['copyArray', 'isLaziable', 'setData'],
    'createRound': ['toInteger', 'toNumber', 'toString'],
    'createSet': ['noop'],
    'createWrapper': ['baseSetData', 'createBaseWrapper', 'createCurryWrapper', 'createHybridWrapper', 'createPartialWrapper', 'getData', 'mergeData', 'setData', 'toInteger'],
    'deburrLetter': [],
    'escapeHtmlChar': [],
    'escapeStringChar': [],
    'equalArrays': ['arraySome'],
    'equalByTag': ['mapToArray', 'setToArray'],
    'equalObjects': ['baseHas', 'keys'],
    'extremumBy': ['baseEach'],
    'getData': ['noop'],
    'getFuncName': [],
    'getIteratee': ['baseIteratee', 'iteratee'],
    'getLength': ['baseProperty'],
    'getMatchData': ['isStrictComparable', 'toPairs'],
    'getNative': ['isNative'],
    'getSymbols': [],
    'getTag': [],
    'getView': [],
    'hasPath': ['isArguments', 'isArray', 'isIndex', 'isKey', 'isLength', 'isString', 'last', 'parent', 'baseToPath'],
    'indexOfNaN': [],
    'initCloneArray': [],
    'initCloneByTag': ['cloneBuffer', 'cloneMap', 'cloneRegExp', 'cloneSet', 'cloneSymbol', 'cloneTypedArray'],
    'initCloneObject': [],
    'indexKeys': ['baseTimes', 'isArguments', 'isArray', 'isLength', 'isString'],
    'isArrayLike': ['getLength', 'isFunction', 'isLength'],
    'isArrayLikeObject': ['isArrayLike', 'isObjectLike'],
    'isHostObject': [],
    'isIndex': [],
    'isIterateeCall': ['eq', 'isArrayLike', 'isIndex', 'isObject'],
    'isKey': ['isArray'],
    'isKeyable': [],
    'isLaziable': ['getData', 'getFuncName', 'LazyWrapper', 'lodash'],
    'isPrototype': [],
    'isSpace': [],
    'isStrictComparable': ['isObject'],
    'iteratorToArray': [],
    'mapToArray': [],
    'mergeData': ['copyArray', 'composeArgs', 'composeArgsRight', 'replaceHolders'],
    'mergeDefaults': ['baseClone', 'baseMerge', 'isObject'],
    'parent': ['baseSlice', 'get'],
    'reorder': ['copyArray', 'isIndex'],
    'replaceHolders': [],
    'setData': ['baseSetData', 'now'],
    'setToArray': [],
    'shimKeys': ['isArguments', 'isArray', 'isIndex', 'isLength', 'isString', 'keysIn'],
    'stringSize': [],
    'stringToArray': [],
    'stringToPath': ['toString'],
    'toArrayLikeObject': ['isArrayLikeObject'],
    'toFunction': ['identity'],
    'trimmedEndIndex': ['isSpace'],
    'trimmedStartIndex': ['isSpace'],
    'unescapeHtmlChar': []
  }),

  /** Used to track lodash object dependencies of identifiers. */
  'objDep': createMap({
    'getFuncName': ['realNames'],
    'main': ['realNames'],
    'template': ['templateSettings']
  }),

  /** Used to map real names to their aliases. */
  'realToAlias': createMap({
    'forEach': ['each'],
    'forEachRight': ['eachRight'],
    'wrapperCommit': ['commit'],
    'wrapperNext': ['next'],
    'wrapperPlant': ['plant'],
    'wrapperToIterator': ['toIterator'],
    'wrapperValue': ['run', 'toJSON', 'value', 'valueOf']
  }),

  /** Used to track variable dependencies of identifiers. */
  'varDep': createMap({

    // Dependencies of variables.
    'Map': ['root'],
    'Reflect': ['root'],
    'Set': ['root'],
    'Symbol': ['root'],
    'Uint8Array': ['root'],
    'WeakMap': ['root'],
    'metaMap': ['WeakMap'],

    // Dependencies of lodash properties.
    'templateSettings': ['reEscape', 'reEvaluate', 'reInterpolate'],

    // Dependencies of the main module.
    'main': ['root', 'Symbol'],

    // Dependencies of hash functions.
    'Hash': ['nativeCreate'],
    'hashGet': ['nativeCreate'],
    'hashHas': ['nativeCreate'],
    'hashSet': ['nativeCreate'],

    // Dependencies of `MapCache` functions.
    'mapClear': ['Map'],
    'mapDelete': ['Map'],
    'mapGet': ['Map'],
    'mapHas': ['Map'],
    'mapSet': ['Map'],

    // Dependencies of lodash methods.
    'isFinite': ['root'],
    'noConflict': ['root'],
    'parseInt': ['root'],
    'template': ['reInterpolate'],
    'toNumber': ['root'],
    'toArray': ['Symbol'],

    // Dependencies of private functions.
    'baseKeysIn': ['Reflect'],
    'baseSetData': ['metaMap'],
    'cloneBuffer': ['Uint8Array'],
    'cloneSymbol': ['Symbol'],
    'createBaseWrapper': ['root'],
    'createCurryWrapper': ['root'],
    'createHybridWrapper': ['root'],
    'createPartialWrapper': ['root'],
    'createSet': ['Set'],
    'equalByTag': ['Symbol', 'Uint8Array'],
    'getData': ['metaMap'],
    'getSymbols': ['root'],
    'getTag': ['Map', 'Set']
  })
};