@types/lodash - npm Package Compare versions

Comparing version 4.14.74 to 4.14.75

lodash/add.d.ts

 import { add } from "./index";
 export = add;

lodash/after.d.ts

 import { after } from "./index";
 export = after;

lodash/ary.d.ts

 import { ary } from "./index";
 export = ary;

lodash/assign.d.ts

 import { assign } from "./index";
 export = assign;

lodash/assignIn.d.ts

 import { assignIn } from "./index";
 export = assignIn;

lodash/assignInWith.d.ts

 import { assignInWith } from "./index";
 export = assignInWith;

lodash/assignWith.d.ts

 import { assignWith } from "./index";
 export = assignWith;

lodash/at.d.ts

 import { at } from "./index";
 export = at;

lodash/attempt.d.ts

 import { attempt } from "./index";
 export = attempt;

lodash/before.d.ts

 import { before } from "./index";
 export = before;

lodash/bind.d.ts

 import { bind } from "./index";
 export = bind;

lodash/bindAll.d.ts

 import { bindAll } from "./index";
 export = bindAll;

lodash/bindKey.d.ts

 import { bindKey } from "./index";
 export = bindKey;

lodash/camelCase.d.ts

 import { camelCase } from "./index";
 export = camelCase;

lodash/capitalize.d.ts

 import { capitalize } from "./index";
 export = capitalize;

lodash/castArray.d.ts

 import { castArray } from "./index";
 export = castArray;

lodash/ceil.d.ts

 import { ceil } from "./index";
 export = ceil;

lodash/chain.d.ts

 import { chain } from "./index";
 export = chain;

lodash/chunk.d.ts

 import { chunk } from "./index";
 export = chunk;

lodash/clamp.d.ts

 import { clamp } from "./index";
 export = clamp;

lodash/clone.d.ts

 import { clone } from "./index";
 export = clone;

lodash/cloneDeep.d.ts

 import { cloneDeep } from "./index";
 export = cloneDeep;

lodash/cloneDeepWith.d.ts

 import { cloneDeepWith } from "./index";
 export = cloneDeepWith;

lodash/cloneWith.d.ts

 import { cloneWith } from "./index";
 export = cloneWith;

lodash/compact.d.ts

 import { compact } from "./index";
 export = compact;

lodash/concat.d.ts

 import { concat } from "./index";
 export = concat;

lodash/constant.d.ts

 import { constant } from "./index";
 export = constant;

lodash/countBy.d.ts

 import { countBy } from "./index";
 export = countBy;

lodash/create.d.ts

 import { create } from "./index";
 export = create;

lodash/curry.d.ts

 import { curry } from "./index";
 export = curry;

lodash/curryRight.d.ts

 import { curryRight } from "./index";
 export = curryRight;

lodash/debounce.d.ts

 import { debounce } from "./index";
 export = debounce;

lodash/deburr.d.ts

 import { deburr } from "./index";
 export = deburr;

lodash/defaults.d.ts

 import { defaults } from "./index";
 export = defaults;

lodash/defaultsDeep.d.ts

 import { defaultsDeep } from "./index";
 export = defaultsDeep;

lodash/defer.d.ts

 import { defer } from "./index";
 export = defer;

lodash/delay.d.ts

 import { delay } from "./index";
 export = delay;

lodash/difference.d.ts

 import { difference } from "./index";
 export = difference;

lodash/differenceBy.d.ts

 import { differenceBy } from "./index";
 export = differenceBy;

lodash/differenceWith.d.ts

 import { differenceWith } from "./index";
 export = differenceWith;

lodash/drop.d.ts

 import { drop } from "./index";
 export = drop;

lodash/dropRight.d.ts

 import { dropRight } from "./index";
 export = dropRight;

lodash/dropRightWhile.d.ts

 import { dropRightWhile } from "./index";
 export = dropRightWhile;

lodash/dropWhile.d.ts

 import { dropWhile } from "./index";
 export = dropWhile;

lodash/each.d.ts

 import { each } from "./index";
 export = each;

lodash/eachRight.d.ts

 import { eachRight } from "./index";
 export = eachRight;

lodash/endsWith.d.ts

 import { endsWith } from "./index";
 export = endsWith;

lodash/eq.d.ts

 import { eq } from "./index";
 export = eq;

lodash/escape.d.ts

 import { escape } from "./index";
 export = escape;

lodash/escapeRegExp.d.ts

 import { escapeRegExp } from "./index";
 export = escapeRegExp;

lodash/every.d.ts

 import { every } from "./index";
 export = every;

lodash/extend.d.ts

 import { extend } from "./index";
 export = extend;

lodash/extendWith.d.ts

 import { extendWith } from "./index";
 export = extendWith;

lodash/fill.d.ts

 import { fill } from "./index";
 export = fill;

lodash/filter.d.ts

 import { filter } from "./index";
 export = filter;

lodash/find.d.ts

 import { find } from "./index";
 export = find;

lodash/findIndex.d.ts

 import { findIndex } from "./index";
 export = findIndex;

lodash/findKey.d.ts

 import { findKey } from "./index";
 export = findKey;

lodash/findLast.d.ts

 import { findLast } from "./index";
 export = findLast;

lodash/findLastIndex.d.ts

 import { findLastIndex } from "./index";
 export = findLastIndex;

lodash/findLastKey.d.ts

 import { findLastKey } from "./index";
 export = findLastKey;

lodash/first.d.ts

 import { first } from "./index";
 export = first;

lodash/flatMap.d.ts

 import { flatMap } from "./index";
 export = flatMap;

lodash/flatten.d.ts

 import { flatten } from "./index";
 export = flatten;

lodash/flattenDeep.d.ts

 import { flattenDeep } from "./index";
 export = flattenDeep;

lodash/flattenDepth.d.ts

 import { flattenDepth } from "./index";
 export = flattenDepth;

lodash/flip.d.ts

 import { flip } from "./index";
 export = flip;

lodash/floor.d.ts

 import { floor } from "./index";
 export = floor;

lodash/flow.d.ts

 import { flow } from "./index";
 export = flow;

lodash/flowRight.d.ts

 import { flowRight } from "./index";
 export = flowRight;

lodash/forEach.d.ts

 import { forEach } from "./index";
 export = forEach;

lodash/forEachRight.d.ts

 import { forEachRight } from "./index";
 export = forEachRight;

lodash/forIn.d.ts

 import { forIn } from "./index";
 export = forIn;

lodash/forInRight.d.ts

 import { forInRight } from "./index";
 export = forInRight;

lodash/forOwn.d.ts

 import { forOwn } from "./index";
 export = forOwn;

lodash/forOwnRight.d.ts

 import { forOwnRight } from "./index";
 export = forOwnRight;

lodash/fromPairs.d.ts

 import { fromPairs } from "./index";
 export = fromPairs;

lodash/functions.d.ts

 import { functions } from "./index";
 export = functions;

lodash/functionsIn.d.ts

 import { functionsIn } from "./index";
 export = functionsIn;

lodash/get.d.ts

 import { get } from "./index";
 export = get;

lodash/groupBy.d.ts

 import { groupBy } from "./index";
 export = groupBy;

lodash/gt.d.ts

 import { gt } from "./index";
 export = gt;

lodash/gte.d.ts

 import { gte } from "./index";
 export = gte;

lodash/has.d.ts

 import { has } from "./index";
 export = has;

lodash/hasIn.d.ts

 import { hasIn } from "./index";
 export = hasIn;

lodash/head.d.ts

 import { head } from "./index";
 export = head;

lodash/identity.d.ts

 import { identity } from "./index";
 export = identity;

lodash/includes.d.ts

 import { includes } from "./index";
 export = includes;

lodash/indexOf.d.ts

 import { indexOf } from "./index";
 export = indexOf;

lodash/initial.d.ts

 import { initial } from "./index";
 export = initial;

lodash/inRange.d.ts

 import { inRange } from "./index";
 export = inRange;

lodash/intersection.d.ts

 import { intersection } from "./index";
 export = intersection;

lodash/intersectionBy.d.ts

 import { intersectionBy } from "./index";
 export = intersectionBy;

lodash/intersectionWith.d.ts

 import { intersectionWith } from "./index";
 export = intersectionWith;

lodash/invert.d.ts

 import { invert } from "./index";
 export = invert;

lodash/invertBy.d.ts

 import { invertBy } from "./index";
 export = invertBy;

lodash/invoke.d.ts

 import { invoke } from "./index";
 export = invoke;

lodash/invokeMap.d.ts

 import { invokeMap } from "./index";
 export = invokeMap;

lodash/isArguments.d.ts

 import { isArguments } from "./index";
 export = isArguments;

lodash/isArray.d.ts

 import { isArray } from "./index";
 export = isArray;

lodash/isArrayBuffer.d.ts

 import { isArrayBuffer } from "./index";
 export = isArrayBuffer;

lodash/isArrayLike.d.ts

 import { isArrayLike } from "./index";
 export = isArrayLike;

lodash/isArrayLikeObject.d.ts

 import { isArrayLikeObject } from "./index";
 export = isArrayLikeObject;

lodash/isBoolean.d.ts

 import { isBoolean } from "./index";
 export = isBoolean;

lodash/isBuffer.d.ts

 import { isBuffer } from "./index";
 export = isBuffer;

lodash/isDate.d.ts

 import { isDate } from "./index";
 export = isDate;

lodash/isElement.d.ts

 import { isElement } from "./index";
 export = isElement;

lodash/isEmpty.d.ts

 import { isEmpty } from "./index";
 export = isEmpty;

lodash/isEqual.d.ts

 import { isEqual } from "./index";
 export = isEqual;

lodash/isEqualWith.d.ts

 import { isEqualWith } from "./index";
 export = isEqualWith;

lodash/isError.d.ts

 import { isError } from "./index";
 export = isError;

lodash/isFinite.d.ts

 import { isFinite } from "./index";
 export = isFinite;

lodash/isFunction.d.ts

 import { isFunction } from "./index";
 export = isFunction;

lodash/isInteger.d.ts

 import { isInteger } from "./index";
 export = isInteger;

lodash/isLength.d.ts

 import { isLength } from "./index";
 export = isLength;

lodash/isMap.d.ts

 import { isMap } from "./index";
 export = isMap;

lodash/isMatch.d.ts

 import { isMatch } from "./index";
 export = isMatch;

lodash/isMatchWith.d.ts

 import { isMatchWith } from "./index";
 export = isMatchWith;

lodash/isNaN.d.ts

 import { isNaN } from "./index";
 export = isNaN;

lodash/isNative.d.ts

 import { isNative } from "./index";
 export = isNative;

lodash/isNil.d.ts

 import { isNil } from "./index";
 export = isNil;

lodash/isNull.d.ts

 import { isNull } from "./index";
 export = isNull;

lodash/isNumber.d.ts

 import { isNumber } from "./index";
 export = isNumber;

lodash/isObject.d.ts

 import { isObject } from "./index";
 export = isObject;

lodash/isObjectLike.d.ts

 import { isObjectLike } from "./index";
 export = isObjectLike;

lodash/isPlainObject.d.ts

 import { isPlainObject } from "./index";
 export = isPlainObject;

lodash/isRegExp.d.ts

 import { isRegExp } from "./index";
 export = isRegExp;

lodash/isSafeInteger.d.ts

 import { isSafeInteger } from "./index";
 export = isSafeInteger;

lodash/isSet.d.ts

 import { isSet } from "./index";
 export = isSet;

lodash/isString.d.ts

 import { isString } from "./index";
 export = isString;

lodash/isSymbol.d.ts

 import { isSymbol } from "./index";
 export = isSymbol;

lodash/isTypedArray.d.ts

 import { isTypedArray } from "./index";
 export = isTypedArray;

lodash/isUndefined.d.ts

 import { isUndefined } from "./index";
 export = isUndefined;

lodash/isWeakMap.d.ts

 import { isWeakMap } from "./index";
 export = isWeakMap;

lodash/isWeakSet.d.ts

 import { isWeakSet } from "./index";
 export = isWeakSet;

lodash/iteratee.d.ts

 import { iteratee } from "./index";
 export = iteratee;

lodash/join.d.ts

 import { join } from "./index";
 export = join;

lodash/kebabCase.d.ts

 import { kebabCase } from "./index";
 export = kebabCase;

lodash/keyBy.d.ts

 import { keyBy } from "./index";
 export = keyBy;

lodash/keys.d.ts

 import { keys } from "./index";
 export = keys;

lodash/keysIn.d.ts

 import { keysIn } from "./index";
 export = keysIn;

lodash/last.d.ts

 import { last } from "./index";
 export = last;

lodash/lastIndexOf.d.ts

 import { lastIndexOf } from "./index";
 export = lastIndexOf;

lodash/lowerCase.d.ts

 import { lowerCase } from "./index";
 export = lowerCase;

lodash/lowerFirst.d.ts

 import { lowerFirst } from "./index";
 export = lowerFirst;

lodash/lt.d.ts

 import { lt } from "./index";
 export = lt;

lodash/lte.d.ts

 import { lte } from "./index";
 export = lte;

lodash/map.d.ts

 import { map } from "./index";
 export = map;

lodash/mapKeys.d.ts

 import { mapKeys } from "./index";
 export = mapKeys;

lodash/mapValues.d.ts

 import { mapValues } from "./index";
 export = mapValues;

lodash/matches.d.ts

 import { matches } from "./index";
 export = matches;

lodash/matchesProperty.d.ts

 import { matchesProperty } from "./index";
 export = matchesProperty;

lodash/max.d.ts

 import { max } from "./index";
 export = max;

lodash/maxBy.d.ts

 import { maxBy } from "./index";
 export = maxBy;

lodash/mean.d.ts

 import { mean } from "./index";
 export = mean;

lodash/meanBy.d.ts

 import { meanBy } from "./index";
 export = meanBy;

lodash/memoize.d.ts

 import { memoize } from "./index";
 export = memoize;

lodash/merge.d.ts

 import { merge } from "./index";
 export = merge;

lodash/mergeWith.d.ts

 import { mergeWith } from "./index";
 export = mergeWith;

lodash/method.d.ts

 import { method } from "./index";
 export = method;

lodash/methodOf.d.ts

 import { methodOf } from "./index";
 export = methodOf;

lodash/min.d.ts

 import { min } from "./index";
 export = min;

lodash/minBy.d.ts

 import { minBy } from "./index";
 export = minBy;

lodash/mixin.d.ts

 import { mixin } from "./index";
 export = mixin;

lodash/negate.d.ts

 import { negate } from "./index";
 export = negate;

lodash/noConflict.d.ts

 import { noConflict } from "./index";
 export = noConflict;

lodash/noop.d.ts

 import { noop } from "./index";
 export = noop;

lodash/now.d.ts

 import { now } from "./index";
 export = now;

lodash/nthArg.d.ts

 import { nthArg } from "./index";
 export = nthArg;

lodash/omit.d.ts

 import { omit } from "./index";
 export = omit;

lodash/omitBy.d.ts

 import { omitBy } from "./index";
 export = omitBy;

lodash/once.d.ts

 import { once } from "./index";
 export = once;

lodash/orderBy.d.ts

 import { orderBy } from "./index";
 export = orderBy;

lodash/over.d.ts

 import { over } from "./index";
 export = over;

lodash/overArgs.d.ts

 import { overArgs } from "./index";
 export = overArgs;

lodash/overEvery.d.ts

 import { overEvery } from "./index";
 export = overEvery;

lodash/overSome.d.ts

 import { overSome } from "./index";
 export = overSome;

lodash/package.json

 {
     "name": "@types/lodash",
-    "version": "4.14.74",
+    "version": "4.14.75",
     "description": "TypeScript definitions for Lo-Dash",
@@ -9,23 +9,29 @@ "license": "MIT",
             "name": "Brian Zengel",
-            "url": "https://github.com/bczengel"
+            "url": "https://github.com/bczengel",
+            "githubUsername": "bczengel"
         },
         {
             "name": "Ilya Mochalov",
-            "url": "https://github.com/chrootsu"
+            "url": "https://github.com/chrootsu",
+            "githubUsername": "chrootsu"
         },
         {
             "name": "Stepan Mikhaylyuk",
-            "url": "https://github.com/stepancar"
+            "url": "https://github.com/stepancar",
+            "githubUsername": "stepancar"
         },
         {
             "name": "Eric L Anderson",
-            "url": "https://github.com/ericanderson"
+            "url": "https://github.com/ericanderson",
+            "githubUsername": "ericanderson"
         },
         {
             "name": "AJ Richardson",
-            "url": "https://github.com/aj-r"
+            "url": "https://github.com/aj-r",
+            "githubUsername": "aj-r"
         },
         {
             "name": "Junyoung Clare Jang",
-            "url": "https://github.com/ailrun"
+            "url": "https://github.com/ailrun",
+            "githubUsername": "ailrun"
         }
@@ -40,4 +46,4 @@ ],
     "dependencies": {},
-    "typesPublisherContentHash": "12af578ffaf8d86d2df37e591857906a86b983fa9258414326544a0fe6af0de8",
+    "typesPublisherContentHash": "647fe2f87b0579afbf7c913210307ee8602f46fcce61f9b33333b296997da270",
     "typeScriptVersion": "2.2"
 }

lodash/pad.d.ts

 import { pad } from "./index";
 export = pad;

lodash/padEnd.d.ts

 import { padEnd } from "./index";
 export = padEnd;

lodash/padStart.d.ts

 import { padStart } from "./index";
 export = padStart;

lodash/parseInt.d.ts

 import { parseInt } from "./index";
 export = parseInt;

lodash/partial.d.ts

 import { partial } from "./index";
 export = partial;

lodash/partialRight.d.ts

 import { partialRight } from "./index";
 export = partialRight;

lodash/partition.d.ts

 import { partition } from "./index";
 export = partition;

lodash/pick.d.ts

 import { pick } from "./index";
 export = pick;

lodash/pickBy.d.ts

 import { pickBy } from "./index";
 export = pickBy;

lodash/property.d.ts

 import { property } from "./index";
 export = property;

lodash/propertyOf.d.ts

 import { propertyOf } from "./index";
 export = propertyOf;

lodash/pull.d.ts

 import { pull } from "./index";
 export = pull;

lodash/pullAll.d.ts

 import { pullAll } from "./index";
 export = pullAll;

lodash/pullAllBy.d.ts

 import { pullAllBy } from "./index";
 export = pullAllBy;

lodash/pullAt.d.ts

 import { pullAt } from "./index";
 export = pullAt;

lodash/random.d.ts

 import { random } from "./index";
 export = random;

lodash/range.d.ts

 import { range } from "./index";
 export = range;

lodash/rangeRight.d.ts

 import { rangeRight } from "./index";
 export = rangeRight;

lodash/README.md

@@ -11,3 +11,3 @@ # Installation
 Additional Details
- * Last updated: Mon, 21 Aug 2017 21:55:03 GMT
+ * Last updated: Mon, 25 Sep 2017 19:36:49 GMT
  * Dependencies: none
@@ -14,0 +14,0 @@ * Global values: _

lodash/rearg.d.ts

 import { rearg } from "./index";
 export = rearg;

lodash/reduce.d.ts

 import { reduce } from "./index";
 export = reduce;

lodash/reduceRight.d.ts

 import { reduceRight } from "./index";
 export = reduceRight;

lodash/reject.d.ts

 import { reject } from "./index";
 export = reject;

lodash/remove.d.ts

 import { remove } from "./index";
 export = remove;

lodash/repeat.d.ts

 import { repeat } from "./index";
 export = repeat;

lodash/replace.d.ts

 import { replace } from "./index";
 export = replace;

lodash/rest.d.ts

 import { rest } from "./index";
 export = rest;

lodash/result.d.ts

 import { result } from "./index";
 export = result;

lodash/reverse.d.ts

 import { reverse } from "./index";
 export = reverse;

lodash/round.d.ts

 import { round } from "./index";
 export = round;

lodash/runInContext.d.ts

 import { runInContext } from "./index";
 export = runInContext;

lodash/sample.d.ts

 import { sample } from "./index";
 export = sample;

lodash/sampleSize.d.ts

 import { sampleSize } from "./index";
 export = sampleSize;

lodash/set.d.ts

 import { set } from "./index";
 export = set;

lodash/setWith.d.ts

 import { setWith } from "./index";
 export = setWith;

lodash/shuffle.d.ts

 import { shuffle } from "./index";
 export = shuffle;

lodash/size.d.ts

 import { size } from "./index";
 export = size;

lodash/slice.d.ts

 import { slice } from "./index";
 export = slice;

lodash/snakeCase.d.ts

 import { snakeCase } from "./index";
 export = snakeCase;

lodash/some.d.ts

 import { some } from "./index";
 export = some;

lodash/sortBy.d.ts

 import { sortBy } from "./index";
 export = sortBy;

lodash/sortedIndex.d.ts

 import { sortedIndex } from "./index";
 export = sortedIndex;

lodash/sortedIndexBy.d.ts

 import { sortedIndexBy } from "./index";
 export = sortedIndexBy;

lodash/sortedIndexOf.d.ts

 import { sortedIndexOf } from "./index";
 export = sortedIndexOf;

lodash/sortedLastIndex.d.ts

 import { sortedLastIndex } from "./index";
 export = sortedLastIndex;

lodash/sortedLastIndexBy.d.ts

 import { sortedLastIndexBy } from "./index";
 export = sortedLastIndexBy;

lodash/sortedLastIndexOf.d.ts

 import { sortedLastIndexOf } from "./index";
 export = sortedLastIndexOf;

lodash/sortedUniq.d.ts

 import { sortedUniq } from "./index";
 export = sortedUniq;

lodash/sortedUniqBy.d.ts

 import { sortedUniqBy } from "./index";
 export = sortedUniqBy;

lodash/split.d.ts

 import { split } from "./index";
 export = split;

lodash/spread.d.ts

 import { spread } from "./index";
 export = spread;

lodash/startCase.d.ts

 import { startCase } from "./index";
 export = startCase;

lodash/startsWith.d.ts

 import { startsWith } from "./index";
 export = startsWith;

lodash/subtract.d.ts

 import { subtract } from "./index";
 export = subtract;

lodash/sum.d.ts

 import { sum } from "./index";
 export = sum;

lodash/sumBy.d.ts

 import { sumBy } from "./index";
 export = sumBy;

lodash/tail.d.ts

 import { tail } from "./index";
 export = tail;

lodash/take.d.ts

 import { take } from "./index";
 export = take;

lodash/takeRight.d.ts

 import { takeRight } from "./index";
 export = takeRight;

lodash/takeRightWhile.d.ts

 import { takeRightWhile } from "./index";
 export = takeRightWhile;

lodash/takeWhile.d.ts

 import { takeWhile } from "./index";
 export = takeWhile;

lodash/tap.d.ts

 import { tap } from "./index";
 export = tap;

lodash/template.d.ts

 import { template } from "./index";
 export = template;

lodash/throttle.d.ts

 import { throttle } from "./index";
 export = throttle;

lodash/thru.d.ts

 import { thru } from "./index";
 export = thru;

lodash/times.d.ts

 import { times } from "./index";
 export = times;

lodash/toArray.d.ts

 import { toArray } from "./index";
 export = toArray;

lodash/toInteger.d.ts

 import { toInteger } from "./index";
 export = toInteger;

lodash/toLength.d.ts

 import { toLength } from "./index";
 export = toLength;

lodash/toLower.d.ts

 import { toLower } from "./index";
 export = toLower;

lodash/toNumber.d.ts

 import { toNumber } from "./index";
 export = toNumber;

lodash/toPairs.d.ts

 import { toPairs } from "./index";
 export = toPairs;

lodash/toPairsIn.d.ts

 import { toPairsIn } from "./index";
 export = toPairsIn;

lodash/toPath.d.ts

 import { toPath } from "./index";
 export = toPath;

lodash/toPlainObject.d.ts

 import { toPlainObject } from "./index";
 export = toPlainObject;

lodash/toSafeInteger.d.ts

 import { toSafeInteger } from "./index";
 export = toSafeInteger;

lodash/toString.d.ts

 import { toString } from "./index";
 export = toString;

lodash/toUpper.d.ts

 import { toUpper } from "./index";
 export = toUpper;

lodash/transform.d.ts

 import { transform } from "./index";
 export = transform;

lodash/trim.d.ts

 import { trim } from "./index";
 export = trim;

lodash/trimEnd.d.ts

 import { trimEnd } from "./index";
 export = trimEnd;

lodash/trimStart.d.ts

 import { trimStart } from "./index";
 export = trimStart;

lodash/truncate.d.ts

 import { truncate } from "./index";
 export = truncate;

lodash/unary.d.ts

 import { unary } from "./index";
 export = unary;

lodash/unescape.d.ts

 import { unescape } from "./index";
 export = unescape;

lodash/union.d.ts

 import { union } from "./index";
 export = union;

lodash/unionBy.d.ts

 import { unionBy } from "./index";
 export = unionBy;

lodash/unionWith.d.ts

 import { unionWith } from "./index";
 export = unionWith;

lodash/uniq.d.ts

 import { uniq } from "./index";
 export = uniq;

lodash/uniqBy.d.ts

 import { uniqBy } from "./index";
 export = uniqBy;

lodash/uniqueId.d.ts

 import { uniqueId } from "./index";
 export = uniqueId;

lodash/uniqWith.d.ts

 import { uniqWith } from "./index";
 export = uniqWith;

lodash/unset.d.ts

 import { unset } from "./index";
 export = unset;

lodash/unzip.d.ts

 import { unzip } from "./index";
 export = unzip;

lodash/unzipWith.d.ts

 import { unzipWith } from "./index";
 export = unzipWith;

lodash/update.d.ts

 import { update } from "./index";
 export = update;

lodash/upperCase.d.ts

 import { upperCase } from "./index";
 export = upperCase;

lodash/upperFirst.d.ts

 import { upperFirst } from "./index";
 export = upperFirst;

lodash/values.d.ts

 import { values } from "./index";
 export = values;

lodash/valuesIn.d.ts

 import { valuesIn } from "./index";
 export = valuesIn;

lodash/without.d.ts

 import { without } from "./index";
 export = without;

lodash/words.d.ts

 import { words } from "./index";
 export = words;

lodash/wrap.d.ts

 import { wrap } from "./index";
 export = wrap;

lodash/xor.d.ts

 import { xor } from "./index";
 export = xor;

lodash/xorBy.d.ts

 import { xorBy } from "./index";
 export = xorBy;

lodash/xorWith.d.ts

 import { xorWith } from "./index";
 export = xorWith;

lodash/zip.d.ts

 import { zip } from "./index";
 export = zip;

lodash/zipObject.d.ts

 import { zipObject } from "./index";
 export = zipObject;

lodash/zipWith.d.ts

 import { zipWith } from "./index";
 export = zipWith;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

610037

increased by3.45%

No dependency changes