@@ -0,0 +1,34 @@
		var arrayMap = require('./_arrayMap'),
		baseIteratee = require('./_baseIteratee'),
		baseMap = require('./_baseMap'),
		baseSortBy = require('./_baseSortBy'),
		baseUnary = require('./_baseUnary'),
		compareMultiple = require('./_compareMultiple'),
		identity = require('./identity');
		/**
		* The base implementation of `_.orderBy` without param guards.
		*
		* @private
		* @param {Array|Object} collection The collection to iterate over.
		* @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
		* @param {string[]} orders The sort orders of `iteratees`.
		* @returns {Array} Returns the new sorted array.
		*/
		function baseOrderBy(collection, iteratees, orders) {
		var index = -1;
		iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
		var result = baseMap(collection, function(value, key, collection) {
		var criteria = arrayMap(iteratees, function(iteratee) {
		return iteratee(value);
		});
		return { 'criteria': criteria, 'index': ++index, 'value': value };
		});
		return baseSortBy(result, function(object, other) {
		return compareMultiple(object, other, orders);
		});
		}
		module.exports = baseOrderBy;

		@@ -0,0 +1,19 @@
		var basePickBy = require('./_basePickBy'),
		hasIn = require('./hasIn');
		/**
		* The base implementation of `_.pick` without support for individual
		* property identifiers.
		*
		* @private
		* @param {Object} object The source object.
		* @param {string[]} paths The property paths to pick.
		* @returns {Object} Returns the new object.
		*/
		function basePick(object, paths) {
		return basePickBy(object, paths, function(value, path) {
		return hasIn(object, path);
		});
		}
		module.exports = basePick;

		@@ -0,0 +1,30 @@
		var baseGet = require('./_baseGet'),
		baseSet = require('./_baseSet'),
		castPath = require('./_castPath');
		/**
		* The base implementation of `_.pickBy` without support for iteratee shorthands.
		*
		* @private
		* @param {Object} object The source object.
		* @param {string[]} paths The property paths to pick.
		* @param {Function} predicate The function invoked per property.
		* @returns {Object} Returns the new object.
		*/
		function basePickBy(object, paths, predicate) {
		var index = -1,
		length = paths.length,
		result = {};
		while (++index < length) {
		var path = paths[index],
		value = baseGet(object, path);
		if (predicate(value, path)) {
		baseSet(result, castPath(path, object), value);
		}
		}
		return result;
		}
		module.exports = basePickBy;

		@@ -0,0 +1,14 @@
		/**
		* The base implementation of `_.property` without support for deep paths.
		*
		* @private
		* @param {string} key The key of the property to get.
		* @returns {Function} Returns the new accessor function.
		*/
		function baseProperty(key) {
		return function(object) {
		return object == null ? undefined : object[key];
		};
		}
		module.exports = baseProperty;

		@@ -0,0 +1,16 @@
		var baseGet = require('./_baseGet');
		/**
		* A specialized version of `baseProperty` which supports deep paths.
		*
		* @private
		* @param {Array|string} path The path of the property to get.
		* @returns {Function} Returns the new accessor function.
		*/
		function basePropertyDeep(path) {
		return function(object) {
		return baseGet(object, path);
		};
		}
		module.exports = basePropertyDeep;

		@@ -0,0 +1,14 @@
		/**
		* The base implementation of `_.propertyOf` without support for deep paths.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Function} Returns the new accessor function.
		*/
		function basePropertyOf(object) {
		return function(key) {
		return object == null ? undefined : object[key];
		};
		}
		module.exports = basePropertyOf;

		@@ -0,0 +1,51 @@
		var arrayMap = require('./_arrayMap'),
		baseIndexOf = require('./_baseIndexOf'),
		baseIndexOfWith = require('./_baseIndexOfWith'),
		baseUnary = require('./_baseUnary'),
		copyArray = require('./_copyArray');
		/** Used for built-in method references. */
		var arrayProto = Array.prototype;
		/** Built-in value references. */
		var splice = arrayProto.splice;
		/**
		* The base implementation of `_.pullAllBy` without support for iteratee
		* shorthands.
		*
		* @private
		* @param {Array} array The array to modify.
		* @param {Array} values The values to remove.
		* @param {Function} [iteratee] The iteratee invoked per element.
		* @param {Function} [comparator] The comparator invoked per element.
		* @returns {Array} Returns `array`.
		*/
		function basePullAll(array, values, iteratee, comparator) {
		var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
		index = -1,
		length = values.length,
		seen = array;
		if (array === values) {
		values = copyArray(values);
		}
		if (iteratee) {
		seen = arrayMap(array, baseUnary(iteratee));
		}
		while (++index < length) {
		var fromIndex = 0,
		value = values[index],
		computed = iteratee ? iteratee(value) : value;
		while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
		if (seen !== array) {
		splice.call(seen, fromIndex, 1);
		}
		splice.call(array, fromIndex, 1);
		}
		}
		return array;
		}
		module.exports = basePullAll;

		@@ -0,0 +1,37 @@
		var baseUnset = require('./_baseUnset'),
		isIndex = require('./_isIndex');
		/** Used for built-in method references. */
		var arrayProto = Array.prototype;
		/** Built-in value references. */
		var splice = arrayProto.splice;
		/**
		* The base implementation of `_.pullAt` without support for individual
		* indexes or capturing the removed elements.
		*
		* @private
		* @param {Array} array The array to modify.
		* @param {number[]} indexes The indexes of elements to remove.
		* @returns {Array} Returns `array`.
		*/
		function basePullAt(array, indexes) {
		var length = array ? indexes.length : 0,
		lastIndex = length - 1;
		while (length--) {
		var index = indexes[length];
		if (length == lastIndex || index !== previous) {
		var previous = index;
		if (isIndex(index)) {
		splice.call(array, index, 1);
		} else {
		baseUnset(array, index);
		}
		}
		}
		return array;
		}
		module.exports = basePullAt;

		@@ -0,0 +1,18 @@
		/* Built-in method references for those with the same name as other `lodash` methods. */
		var nativeFloor = Math.floor,
		nativeRandom = Math.random;
		/**
		* The base implementation of `_.random` without support for returning
		* floating-point numbers.
		*
		* @private
		* @param {number} lower The lower bound.
		* @param {number} upper The upper bound.
		* @returns {number} Returns the random number.
		*/
		function baseRandom(lower, upper) {
		return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
		}
		module.exports = baseRandom;

		@@ -0,0 +1,28 @@
		/* Built-in method references for those with the same name as other `lodash` methods. */
		var nativeCeil = Math.ceil,
		nativeMax = Math.max;
		/**
		* The base implementation of `_.range` and `_.rangeRight` which doesn't
		* coerce arguments.
		*
		* @private
		* @param {number} start The start of the range.
		* @param {number} end The end of the range.
		* @param {number} step The value to increment or decrement by.
		* @param {boolean} [fromRight] Specify iterating from right to left.
		* @returns {Array} Returns the range of numbers.
		*/
		function baseRange(start, end, step, fromRight) {
		var index = -1,
		length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
		result = Array(length);
		while (length--) {
		result[fromRight ? length : ++index] = start;
		start += step;
		}
		return result;
		}
		module.exports = baseRange;

		@@ -0,0 +1,23 @@
		/**
		* The base implementation of `_.reduce` and `_.reduceRight`, without support
		* for iteratee shorthands, which iterates over `collection` using `eachFunc`.
		*
		* @private
		* @param {Array|Object} collection The collection to iterate over.
		* @param {Function} iteratee The function invoked per iteration.
		* @param {*} accumulator The initial value.
		* @param {boolean} initAccum Specify using the first or last element of
		* `collection` as the initial value.
		* @param {Function} eachFunc The function to iterate over `collection`.
		* @returns {*} Returns the accumulated value.
		*/
		function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
		eachFunc(collection, function(value, index, collection) {
		accumulator = initAccum
		? (initAccum = false, value)
		: iteratee(accumulator, value, index, collection);
		});
		return accumulator;
		}
		module.exports = baseReduce;

		@@ -0,0 +1,35 @@
		/** Used as references for various `Number` constants. */
		var MAX_SAFE_INTEGER = 9007199254740991;
		/* Built-in method references for those with the same name as other `lodash` methods. */
		var nativeFloor = Math.floor;
		/**
		* The base implementation of `_.repeat` which doesn't coerce arguments.
		*
		* @private
		* @param {string} string The string to repeat.
		* @param {number} n The number of times to repeat the string.
		* @returns {string} Returns the repeated string.
		*/
		function baseRepeat(string, n) {
		var result = '';
		if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
		return result;
		}
		// Leverage the exponentiation by squaring algorithm for a faster repeat.
		// See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
		do {
		if (n % 2) {
		result += string;
		}
		n = nativeFloor(n / 2);
		if (n) {
		string += string;
		}
		} while (n);
		return result;
		}
		module.exports = baseRepeat;

		@@ -0,0 +1,17 @@
		var identity = require('./identity'),
		overRest = require('./_overRest'),
		setToString = require('./_setToString');
		/**
		* The base implementation of `_.rest` which doesn't validate or coerce arguments.
		*
		* @private
		* @param {Function} func The function to apply a rest parameter to.
		* @param {number} [start=func.length-1] The start position of the rest parameter.
		* @returns {Function} Returns the new function.
		*/
		function baseRest(func, start) {
		return setToString(overRest(func, start, identity), func + '');
		}
		module.exports = baseRest;

		@@ -0,0 +1,15 @@
		var arraySample = require('./_arraySample'),
		values = require('./values');
		/**
		* The base implementation of `_.sample`.
		*
		* @private
		* @param {Array|Object} collection The collection to sample.
		* @returns {*} Returns the random element.
		*/
		function baseSample(collection) {
		return arraySample(values(collection));
		}
		module.exports = baseSample;

		@@ -0,0 +1,18 @@
		var baseClamp = require('./_baseClamp'),
		shuffleSelf = require('./_shuffleSelf'),
		values = require('./values');
		/**
		* The base implementation of `_.sampleSize` without param guards.
		*
		* @private
		* @param {Array|Object} collection The collection to sample.
		* @param {number} n The number of elements to sample.
		* @returns {Array} Returns the random elements.
		*/
		function baseSampleSize(collection, n) {
		var array = values(collection);
		return shuffleSelf(array, baseClamp(n, 0, array.length));
		}
		module.exports = baseSampleSize;

		@@ -0,0 +1,47 @@
		var assignValue = require('./_assignValue'),
		castPath = require('./_castPath'),
		isIndex = require('./_isIndex'),
		isObject = require('./isObject'),
		toKey = require('./_toKey');
		/**
		* The base implementation of `_.set`.
		*
		* @private
		* @param {Object} object The object to modify.
		* @param {Array|string} path The path of the property to set.
		* @param {*} value The value to set.
		* @param {Function} [customizer] The function to customize path creation.
		* @returns {Object} Returns `object`.
		*/
		function baseSet(object, path, value, customizer) {
		if (!isObject(object)) {
		return object;
		}
		path = castPath(path, object);
		var index = -1,
		length = path.length,
		lastIndex = length - 1,
		nested = object;
		while (nested != null && ++index < length) {
		var key = toKey(path[index]),
		newValue = value;
		if (index != lastIndex) {
		var objValue = nested[key];
		newValue = customizer ? customizer(objValue, key, nested) : undefined;
		if (newValue === undefined) {
		newValue = isObject(objValue)
		? objValue
		: (isIndex(path[index + 1]) ? [] : {});
		}
		}
		assignValue(nested, key, newValue);
		nested = nested[key];
		}
		return object;
		}
		module.exports = baseSet;

		@@ -0,0 +1,17 @@
		var identity = require('./identity'),
		metaMap = require('./_metaMap');
		/**
		* The base implementation of `setData` without support for hot loop shorting.
		*
		* @private
		* @param {Function} func The function to associate metadata with.
		* @param {*} data The metadata.
		* @returns {Function} Returns `func`.
		*/
		var baseSetData = !metaMap ? identity : function(func, data) {
		metaMap.set(func, data);
		return func;
		};
		module.exports = baseSetData;

		@@ -0,0 +1,22 @@
		var constant = require('./constant'),
		defineProperty = require('./_defineProperty'),
		identity = require('./identity');
		/**
		* The base implementation of `setToString` without support for hot loop shorting.
		*
		* @private
		* @param {Function} func The function to modify.
		* @param {Function} string The `toString` result.
		* @returns {Function} Returns `func`.
		*/
		var baseSetToString = !defineProperty ? identity : function(func, string) {
		return defineProperty(func, 'toString', {
		'configurable': true,
		'enumerable': false,
		'value': constant(string),
		'writable': true
		});
		};
		module.exports = baseSetToString;

		@@ -0,0 +1,15 @@
		var shuffleSelf = require('./_shuffleSelf'),
		values = require('./values');
		/**
		* The base implementation of `_.shuffle`.
		*
		* @private
		* @param {Array|Object} collection The collection to shuffle.
		* @returns {Array} Returns the new shuffled array.
		*/
		function baseShuffle(collection) {
		return shuffleSelf(values(collection));
		}
		module.exports = baseShuffle;

		@@ -0,0 +1,31 @@
		/**
		* The base implementation of `_.slice` without an iteratee call guard.
		*
		* @private
		* @param {Array} array The array to slice.
		* @param {number} [start=0] The start position.
		* @param {number} [end=array.length] The end position.
		* @returns {Array} Returns the slice of `array`.
		*/
		function baseSlice(array, start, end) {
		var index = -1,
		length = array.length;
		if (start < 0) {
		start = -start > length ? 0 : (length + start);
		}
		end = end > length ? length : end;
		if (end < 0) {
		end += length;
		}
		length = start > end ? 0 : ((end - start) >>> 0);
		start >>>= 0;
		var result = Array(length);
		while (++index < length) {
		result[index] = array[index + start];
		}
		return result;
		}
		module.exports = baseSlice;

		@@ -0,0 +1,22 @@
		var baseEach = require('./_baseEach');
		/**
		* The base implementation of `_.some` without support for iteratee shorthands.
		*
		* @private
		* @param {Array|Object} collection The collection to iterate over.
		* @param {Function} predicate The function invoked per iteration.
		* @returns {boolean} Returns `true` if any element passes the predicate check,
		* else `false`.
		*/
		function baseSome(collection, predicate) {
		var result;
		baseEach(collection, function(value, index, collection) {
		result = predicate(value, index, collection);
		return !result;
		});
		return !!result;
		}
		module.exports = baseSome;

		@@ -0,0 +1,21 @@
		/**
		* The base implementation of `_.sortBy` which uses `comparer` to define the
		* sort order of `array` and replaces criteria objects with their corresponding
		* values.
		*
		* @private
		* @param {Array} array The array to sort.
		* @param {Function} comparer The function to define sort order.
		* @returns {Array} Returns `array`.
		*/
		function baseSortBy(array, comparer) {
		var length = array.length;
		array.sort(comparer);
		while (length--) {
		array[length] = array[length].value;
		}
		return array;
		}
		module.exports = baseSortBy;

		@@ -0,0 +1,42 @@
		var baseSortedIndexBy = require('./_baseSortedIndexBy'),
		identity = require('./identity'),
		isSymbol = require('./isSymbol');
		/** Used as references for the maximum length and index of an array. */
		var MAX_ARRAY_LENGTH = 4294967295,
		HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
		/**
		* The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
		* performs a binary search of `array` to determine the index at which `value`
		* should be inserted into `array` in order to maintain its sort order.
		*
		* @private
		* @param {Array} array The sorted array to inspect.
		* @param {*} value The value to evaluate.
		* @param {boolean} [retHighest] Specify returning the highest qualified index.
		* @returns {number} Returns the index at which `value` should be inserted
		* into `array`.
		*/
		function baseSortedIndex(array, value, retHighest) {
		var low = 0,
		high = array == null ? low : array.length;
		if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
		while (low < high) {
		var mid = (low + high) >>> 1,
		computed = array[mid];
		if (computed !== null && !isSymbol(computed) &&
		(retHighest ? (computed <= value) : (computed < value))) {
		low = mid + 1;
		} else {
		high = mid;
		}
		}
		return high;
		}
		return baseSortedIndexBy(array, value, identity, retHighest);
		}
		module.exports = baseSortedIndex;

		@@ -0,0 +1,64 @@
		var isSymbol = require('./isSymbol');
		/** Used as references for the maximum length and index of an array. */
		var MAX_ARRAY_LENGTH = 4294967295,
		MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
		/* Built-in method references for those with the same name as other `lodash` methods. */
		var nativeFloor = Math.floor,
		nativeMin = Math.min;
		/**
		* The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
		* which invokes `iteratee` for `value` and each element of `array` to compute
		* their sort ranking. The iteratee is invoked with one argument; (value).
		*
		* @private
		* @param {Array} array The sorted array to inspect.
		* @param {*} value The value to evaluate.
		* @param {Function} iteratee The iteratee invoked per element.
		* @param {boolean} [retHighest] Specify returning the highest qualified index.
		* @returns {number} Returns the index at which `value` should be inserted
		* into `array`.
		*/
		function baseSortedIndexBy(array, value, iteratee, retHighest) {
		value = iteratee(value);
		var low = 0,
		high = array == null ? 0 : array.length,
		valIsNaN = value !== value,
		valIsNull = value === null,
		valIsSymbol = isSymbol(value),
		valIsUndefined = value === undefined;
		while (low < high) {
		var mid = nativeFloor((low + high) / 2),
		computed = iteratee(array[mid]),
		othIsDefined = computed !== undefined,
		othIsNull = computed === null,
		othIsReflexive = computed === computed,
		othIsSymbol = isSymbol(computed);
		if (valIsNaN) {
		var setLow = retHighest || othIsReflexive;
		} else if (valIsUndefined) {
		setLow = othIsReflexive && (retHighest || othIsDefined);
		} else if (valIsNull) {
		setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
		} else if (valIsSymbol) {
		setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
		} else if (othIsNull || othIsSymbol) {
		setLow = false;
		} else {
		setLow = retHighest ? (computed <= value) : (computed < value);
		}
		if (setLow) {
		low = mid + 1;
		} else {
		high = mid;
		}
		}
		return nativeMin(high, MAX_ARRAY_INDEX);
		}
		module.exports = baseSortedIndexBy;

		@@ -0,0 +1,30 @@
		var eq = require('./eq');
		/**
		* The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
		* support for iteratee shorthands.
		*
		* @private
		* @param {Array} array The array to inspect.
		* @param {Function} [iteratee] The iteratee invoked per element.
		* @returns {Array} Returns the new duplicate free array.
		*/
		function baseSortedUniq(array, iteratee) {
		var index = -1,
		length = array.length,
		resIndex = 0,
		result = [];
		while (++index < length) {
		var value = array[index],
		computed = iteratee ? iteratee(value) : value;
		if (!index || !eq(computed, seen)) {
		var seen = computed;
		result[resIndex++] = value === 0 ? 0 : value;
		}
		}
		return result;
		}
		module.exports = baseSortedUniq;

		@@ -0,0 +1,24 @@
		/**
		* The base implementation of `_.sum` and `_.sumBy` without support for
		* iteratee shorthands.
		*
		* @private
		* @param {Array} array The array to iterate over.
		* @param {Function} iteratee The function invoked per iteration.
		* @returns {number} Returns the sum.
		*/
		function baseSum(array, iteratee) {
		var result,
		index = -1,
		length = array.length;
		while (++index < length) {
		var current = iteratee(array[index]);
		if (current !== undefined) {
		result = result === undefined ? current : (result + current);
		}
		}
		return result;
		}
		module.exports = baseSum;

		@@ -0,0 +1,20 @@
		/**
		* The base implementation of `_.times` without support for iteratee shorthands
		* or max array length checks.
		*
		* @private
		* @param {number} n The number of times to invoke `iteratee`.
		* @param {Function} iteratee The function invoked per iteration.
		* @returns {Array} Returns the array of results.
		*/
		function baseTimes(n, iteratee) {
		var index = -1,
		result = Array(n);
		while (++index < n) {
		result[index] = iteratee(index);
		}
		return result;
		}
		module.exports = baseTimes;