es-toolkit 1.18.0 → 1.19.0

package/dist/compat/index.js

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-CYaH1Y.js');
+const zipWith = require('../_chunk/zipWith-B-5AMf.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const rest$1 = require('../_chunk/rest-CXt9w3.js');
-const math_index = require('../math/index.js');
+const curry = require('../_chunk/curry-BmwJrK.js');
+const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-DN1PPP.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-CogETi.js');
-const isTypedArray$1 = require('../_chunk/isTypedArray-Dsrnb1.js');
+const toMerged = require('../_chunk/toMerged-Bzkqyz.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-E_VMwB.js');
+const isPlainObject$1 = require('../_chunk/isPlainObject-BIekvL.js');
 const string_index = require('../string/index.js');
 
 function castArray(value) {
@@ -49,8 +49,6 @@ function fill(array, value, start = 0, end = array.length) {
     return zipWith.fill(array, value, start, end);
 }
 
-const IS_PLAIN = /^\w*$/;
-const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 function isDeepKey(key) {
     switch (typeof key) {
         case 'number':
@@ -58,43 +56,39 @@ function isDeepKey(key) {
             return false;
         }
         case 'string': {
-            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+            return key.includes('.') || key.includes('[') || key.includes(']');
         }
     }
 }
 
-function isSymbol(value) {
-    return typeof value === 'symbol' || (value != null && value instanceof Symbol);
-}
-
 function toKey(value) {
-    if (typeof value === 'string' || isSymbol(value)) {
-        return value;
-    }
-    if (Object.is(value?.valueOf(), -0)) {
+    if (Object.is(value, -0)) {
         return '-0';
     }
-    return `${value}`;
+    return value.toString();
 }
 
+const DOTS_KEY = /^[\w.]+$/g;
+const ESCAPE_REGEXP = /\\(\\)?/g;
+const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
+    '|' +
+    '\\[(?:' +
+    '([^"\'][^[]*)' +
+    '|' +
+    '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+    ')\\]' +
+    '|' +
+    '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
 function toPath(deepKey) {
-    const ESCAPE_REGEXP = /\\(\\)?/g;
-    const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
-        '|' +
-        '\\[(?:' +
-        '([^"\'][^[]*)' +
-        '|' +
-        '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
-        ')\\]' +
-        '|' +
-        '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
+    if (DOTS_KEY.test(deepKey)) {
+        return deepKey.split('.');
+    }
     const result = [];
     if (deepKey[0] === '.') {
         result.push('');
     }
-    let match;
-    let lastIndex = 0;
-    while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+    const matches = deepKey.matchAll(PROPERTY_REGEXP);
+    for (const match of matches) {
         let key = match[0];
         const expr = match[1];
         const quote = match[2];
@@ -106,40 +100,71 @@ function toPath(deepKey) {
             key = expr;
         }
         result.push(key);
-        if (PROPERTY_REGEXP.lastIndex === lastIndex) {
-            PROPERTY_REGEXP.lastIndex++;
-        }
-        else {
-            lastIndex = PROPERTY_REGEXP.lastIndex;
-        }
     }
     return result;
 }
 
 function get(object, path, defaultValue) {
-    let resolvedPath;
-    if (Array.isArray(path)) {
-        resolvedPath = path;
-    }
-    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
-        resolvedPath = toPath(path);
+    if (object == null) {
+        return defaultValue;
     }
-    else {
-        resolvedPath = [path];
+    switch (typeof path) {
+        case 'string': {
+            const result = object[path];
+            if (result === undefined) {
+                if (isDeepKey(path)) {
+                    return get(object, toPath(path), defaultValue);
+                }
+                else {
+                    return defaultValue;
+                }
+            }
+            return result;
+        }
+        case 'number':
+        case 'symbol': {
+            if (typeof path === 'number') {
+                path = toKey(path);
+            }
+            const result = object[path];
+            if (result === undefined) {
+                return defaultValue;
+            }
+            return result;
+        }
+        default: {
+            if (Array.isArray(path)) {
+                return getWithPath(object, path, defaultValue);
+            }
+            if (Object.is(path?.valueOf(), -0)) {
+                path = '-0';
+            }
+            else {
+                path = String(path);
+            }
+            const result = object[path];
+            if (result === undefined) {
+                return defaultValue;
+            }
+            return result;
+        }
     }
-    if (resolvedPath.length === 0) {
+}
+function getWithPath(object, path, defaultValue) {
+    if (path.length === 0) {
         return defaultValue;
     }
     let current = object;
-    let index;
-    for (index = 0; index < resolvedPath.length && current != null; index++) {
-        const key = toKey(resolvedPath[index]);
-        current = current[key];
+    for (let index = 0; index < path.length; index++) {
+        if (current == null) {
+            return defaultValue;
+        }
+        current = current[path[index]];
     }
-    if (current === null && index === resolvedPath.length) {
-        return current;
+    if (current === undefined) {
+        return defaultValue;
     }
-    return current ?? defaultValue;
+    return current;
 }
 
 function property(path) {
@@ -148,52 +173,6 @@ function property(path) {
     };
 }
 
-function isArrayMatch(target, source) {
-    if (source.length === 0) {
-        return true;
-    }
-    if (!Array.isArray(target)) {
-        return false;
-    }
-    const countedIndex = new Set();
-    for (let i = 0; i < source.length; i++) {
-        const sourceItem = source[i];
-        const index = target.findIndex((targetItem, index) => {
-            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
-        });
-        if (index === -1) {
-            return false;
-        }
-        countedIndex.add(index);
-    }
-    return true;
-}
-
-function isMapMatch(target, source) {
-    if (source.size === 0) {
-        return true;
-    }
-    if (!(target instanceof Map)) {
-        return false;
-    }
-    for (const [key, value] of source.entries()) {
-        if (!isMatch(target.get(key), value)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-function isSetMatch(target, source) {
-    if (source.size === 0) {
-        return true;
-    }
-    if (!(target instanceof Set)) {
-        return false;
-    }
-    return isArrayMatch([...target], [...source]);
-}
-
 function isMatch(target, source) {
     if (source === target) {
         return true;
@@ -221,7 +200,7 @@ function isMatch(target, source) {
             }
             for (let i = 0; i < keys.length; i++) {
                 const key = keys[i];
-                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
+                if (!isPlainObject$1.isPrimitive(target) && !(key in target)) {
                     return false;
                 }
                 if (source[key] === undefined && target[key] !== undefined) {
@@ -244,6 +223,49 @@ function isMatch(target, source) {
         }
     }
 }
+function isMapMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Map)) {
+        return false;
+    }
+    for (const [key, value] of source.entries()) {
+        if (!isMatch(target.get(key), value)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isArrayMatch(target, source) {
+    if (source.length === 0) {
+        return true;
+    }
+    if (!Array.isArray(target)) {
+        return false;
+    }
+    const countedIndex = new Set();
+    for (let i = 0; i < source.length; i++) {
+        const sourceItem = source[i];
+        const index = target.findIndex((targetItem, index) => {
+            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
+        });
+        if (index === -1) {
+            return false;
+        }
+        countedIndex.add(index);
+    }
+    return true;
+}
+function isSetMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Set)) {
+        return false;
+    }
+    return isArrayMatch([...target], [...source]);
+}
 
 function matches(source) {
     source = toMerged.cloneDeep(source);
@@ -325,7 +347,18 @@ function has(object, path) {
 }
 
 function matchesProperty(property, source) {
-    property = Array.isArray(property) ? property : toKey(property);
+    switch (typeof property) {
+        case 'object': {
+            if (Object.is(property?.valueOf(), -0)) {
+                property = '-0';
+            }
+            break;
+        }
+        case 'number': {
+            property = toKey(property);
+            break;
+        }
+    }
     source = cloneDeep(source);
     return function (target) {
         const result = get(target, property);
@@ -519,6 +552,10 @@ const compareValues = (a, b, order) => {
     return 0;
 };
 
+function isSymbol(value) {
+    return typeof value === 'symbol' || (value != null && value instanceof Symbol);
+}
+
 const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 const regexIsPlainProp = /^\w*$/;
 function isKey(value, object) {
@@ -684,7 +721,7 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return rest$1.ary(func, n);
+    return curry.ary(func, n);
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -744,7 +781,7 @@ function rest(func, start = func.length - 1) {
     if (Number.isNaN(start) || start < 0) {
         start = func.length - 1;
     }
-    return rest$1.rest(func, start);
+    return curry.rest(func, start);
 }
 
 function spread(func, argsIndex = 0) {
@@ -782,6 +819,134 @@ function rearg(func, ...indices) {
     };
 }
 
+function isNil(x) {
+    return x == null;
+}
+
+function pick(obj, ...keysArr) {
+    if (isNil(obj)) {
+        return {};
+    }
+    const result = {};
+    for (let keys of keysArr) {
+        switch (typeof keys) {
+            case 'object': {
+                if (!Array.isArray(keys)) {
+                    keys = Array.from(keys);
+                }
+                break;
+            }
+            case 'string':
+            case 'symbol':
+            case 'number': {
+                keys = [keys];
+                break;
+            }
+        }
+        for (const key of keys) {
+            const value = get(obj, key);
+            if (typeof key === 'string' && Object.prototype.hasOwnProperty.call(obj, key)) {
+                result[key] = value;
+            }
+            else {
+                set(result, key, value);
+            }
+        }
+    }
+    return result;
+}
+
+function unset(obj, path) {
+    if (obj == null) {
+        return true;
+    }
+    switch (typeof path) {
+        case 'symbol':
+        case 'number':
+        case 'object': {
+            if (Array.isArray(path)) {
+                return unsetWithPath(obj, path);
+            }
+            if (typeof path === 'number') {
+                path = toKey(path);
+            }
+            else if (typeof path === 'object') {
+                if (Object.is(path?.valueOf(), -0)) {
+                    path = '-0';
+                }
+                else {
+                    path = String(path);
+                }
+            }
+            if (obj?.[path] === undefined) {
+                return true;
+            }
+            try {
+                delete obj[path];
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        case 'string': {
+            if (obj?.[path] === undefined && isDeepKey(path)) {
+                return unsetWithPath(obj, toPath(path));
+            }
+            try {
+                delete obj[path];
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+}
+function unsetWithPath(obj, path) {
+    const parent = get(obj, path.slice(0, -1), obj);
+    const lastKey = path[path.length - 1];
+    if (parent?.[lastKey] === undefined) {
+        return true;
+    }
+    try {
+        delete parent[lastKey];
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+function omit(obj, ...keysArr) {
+    if (obj == null) {
+        return {};
+    }
+    const result = toMerged.cloneDeep(obj);
+    for (let i = 0; i < keysArr.length; i++) {
+        let keys = keysArr[i];
+        switch (typeof keys) {
+            case 'object': {
+                if (!Array.isArray(keys)) {
+                    keys = Array.from(keys);
+                }
+                for (let j = 0; j < keys.length; j++) {
+                    const key = keys[j];
+                    unset(result, key);
+                }
+                break;
+            }
+            case 'string':
+            case 'symbol':
+            case 'number': {
+                unset(result, keys);
+                break;
+            }
+        }
+    }
+    return result;
+}
+
 function mapKeys(object, getNewKey) {
     getNewKey = getNewKey ?? identity;
     switch (typeof getNewKey) {
@@ -841,7 +1006,7 @@ function isPlainObject(object) {
 }
 
 function isTypedArray(x) {
-    return isTypedArray$1.isTypedArray(x);
+    return isPlainObject$1.isTypedArray(x);
 }
 
 function mergeWith(object, ...otherArgs) {
@@ -868,7 +1033,7 @@ function mergeWithDeep(target, source, merge, stack) {
             source[i] = source[i] ?? undefined;
         }
     }
-    const sourceKeys = Object.keys(source);
+    const sourceKeys = [...Object.keys(source), ...isWeakSet$1.getSymbols(source)];
     for (let i = 0; i < sourceKeys.length; i++) {
         const key = sourceKeys[i];
         let sourceValue = source[key];
@@ -883,7 +1048,18 @@ function mergeWithDeep(target, source, merge, stack) {
             sourceValue = cloneDeep(sourceValue);
         }
         if (Array.isArray(sourceValue)) {
-            targetValue = typeof targetValue === 'object' ? Array.from(targetValue ?? []) : [];
+            if (typeof targetValue === 'object') {
+                const cloned = [];
+                const targetKeys = Reflect.ownKeys(targetValue);
+                for (let i = 0; i < targetKeys.length; i++) {
+                    const targetKey = targetKeys[i];
+                    cloned[targetKey] = targetValue[targetKey];
+                }
+                targetValue = cloned;
+            }
+            else {
+                targetValue = [];
+            }
         }
         const merged = merge(targetValue, sourceValue, key, target, source, stack);
         if (merged != null) {
@@ -909,7 +1085,7 @@ function mergeWithDeep(target, source, merge, stack) {
 }
 
 function merge(object, ...sources) {
-    return mergeWith(object, ...sources, rest$1.noop);
+    return mergeWith(object, ...sources, curry.noop);
 }
 
 function isArrayLike(value) {
@@ -991,18 +1167,55 @@ function conforms(source) {
     };
 }
 
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+
+function isSafeInteger(value) {
+    return Number.isSafeInteger(value);
+}
+
+function toString(value) {
+    if (value == null) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.map(toString).join(',');
+    }
+    const result = String(value);
+    if (result === '0' && Object.is(Number(value), -0)) {
+        return '-0';
+    }
+    return result;
+}
+
 function normalizeForCase(str) {
-    if (typeof str === 'object') {
-        str = str.toString();
+    if (typeof str !== 'string') {
+        str = toString(str);
     }
-    str = str.replace(/['\u2019]/g, '');
-    return str;
+    return str.replace(/['\u2019]/g, '');
 }
 
 function camelCase(str) {
     return string_index.camelCase(normalizeForCase(str));
 }
 
+function kebabCase(str) {
+    return string_index.kebabCase(normalizeForCase(str));
+}
+
+function snakeCase(str) {
+    return string_index.snakeCase(normalizeForCase(str));
+}
+
+function startCase(str) {
+    return string_index.startCase(normalizeForCase(str));
+}
+
+function lowerCase(str) {
+    return string_index.lowerCase(normalizeForCase(str));
+}
+
 function startsWith(str, target, position = 0) {
     return str.startsWith(target, position);
 }
@@ -1023,6 +1236,72 @@ function repeat(str, n) {
     return str.repeat(n);
 }
 
+function trim(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trim();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return string_index.trim(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return string_index.trim(str, chars.map(x => x.toString()));
+            }
+            else {
+                return string_index.trim(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
+function trimStart(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trimStart();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return string_index.trimStart(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return string_index.trimStart(str, chars.map(x => x.toString()));
+            }
+            else {
+                return string_index.trimStart(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
+function trimEnd(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trimEnd();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return string_index.trimEnd(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return string_index.trimEnd(str, chars.map(x => x.toString()));
+            }
+            else {
+                return string_index.trimEnd(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
 function max(items = []) {
     let maxElement = items[0];
     let max = undefined;
@@ -1047,6 +1326,36 @@ function min(items = []) {
     return minElement;
 }
 
+function decimalAdjust(type, number, precision = 0) {
+    number = Number(number);
+    if (Object.is(number, -0)) {
+        number = '-0';
+    }
+    precision = Math.min(Number.parseInt(precision, 10), 292);
+    if (precision) {
+        const [magnitude, exponent = 0] = number.toString().split('e');
+        let adjustedValue = Math[type](Number(`${magnitude}e${Number(exponent) + precision}`));
+        if (Object.is(adjustedValue, -0)) {
+            adjustedValue = '-0';
+        }
+        const [newMagnitude, newExponent = 0] = adjustedValue.toString().split('e');
+        return Number(`${newMagnitude}e${Number(newExponent) - precision}`);
+    }
+    return Math[type](Number(number));
+}
+
+function ceil(number, precision = 0) {
+    return decimalAdjust('ceil', number, precision);
+}
+
+function floor(number, precision = 0) {
+    return decimalAdjust('floor', number, precision);
+}
+
+function round(number, precision = 0) {
+    return decimalAdjust('round', number, precision);
+}
+
 function parseInt(string, radix = 0, guard) {
     if (guard) {
         radix = 0;
@@ -1109,25 +1418,25 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = rest$1.after;
-exports.before = rest$1.before;
-exports.debounce = rest$1.debounce;
-exports.memoize = rest$1.memoize;
-exports.negate = rest$1.negate;
-exports.noop = rest$1.noop;
-exports.once = rest$1.once;
-exports.partial = rest$1.partial;
-exports.partialRight = rest$1.partialRight;
-exports.throttle = rest$1.throttle;
-exports.unary = rest$1.unary;
-exports.clamp = math_index.clamp;
-exports.inRange = math_index.inRange;
-exports.mean = math_index.mean;
-exports.meanBy = math_index.meanBy;
-exports.range = math_index.range;
-exports.round = math_index.round;
-exports.sum = math_index.sum;
-exports.sumBy = math_index.sumBy;
+exports.after = curry.after;
+exports.before = curry.before;
+exports.curry = curry.curry;
+exports.debounce = curry.debounce;
+exports.memoize = curry.memoize;
+exports.negate = curry.negate;
+exports.noop = curry.noop;
+exports.once = curry.once;
+exports.partial = curry.partial;
+exports.partialRight = curry.partialRight;
+exports.throttle = curry.throttle;
+exports.unary = curry.unary;
+exports.clamp = range.clamp;
+exports.inRange = range.inRange;
+exports.mean = range.mean;
+exports.meanBy = range.meanBy;
+exports.range = range.range;
+exports.sum = range.sum;
+exports.sumBy = range.sumBy;
 exports.random = randomInt.random;
 exports.randomInt = randomInt.randomInt;
 exports.clone = toMerged.clone;
@@ -1135,11 +1444,10 @@ exports.cloneDeep = toMerged.cloneDeep;
 exports.flattenObject = toMerged.flattenObject;
 exports.invert = toMerged.invert;
 exports.isObjectLike = toMerged.isObjectLike;
-exports.omit = toMerged.omit;
 exports.omitBy = toMerged.omitBy;
-exports.pick = toMerged.pick;
 exports.pickBy = toMerged.pickBy;
 exports.toMerged = toMerged.toMerged;
+exports.isDate = isWeakSet$1.isDate;
 exports.isEqual = isWeakSet$1.isEqual;
 exports.isFunction = isWeakSet$1.isFunction;
 exports.isLength = isWeakSet$1.isLength;
@@ -1147,19 +1455,16 @@ exports.isNil = isWeakSet$1.isNil;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isUndefined = isWeakSet$1.isUndefined;
-exports.isPrimitive = isTypedArray$1.isPrimitive;
+exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.capitalize = string_index.capitalize;
 exports.deburr = string_index.deburr;
 exports.escape = string_index.escape;
 exports.escapeRegExp = string_index.escapeRegExp;
-exports.kebabCase = string_index.kebabCase;
-exports.lowerCase = string_index.lowerCase;
 exports.lowerFirst = string_index.lowerFirst;
 exports.pad = string_index.pad;
 exports.pascalCase = string_index.pascalCase;
-exports.snakeCase = string_index.snakeCase;
-exports.startCase = string_index.startCase;
 exports.unescape = string_index.unescape;
+exports.upperCase = string_index.upperCase;
 exports.upperFirst = string_index.upperFirst;
 exports.ary = ary;
 exports.attempt = attempt;
@@ -1167,6 +1472,7 @@ exports.bind = bind;
 exports.bindKey = bindKey;
 exports.camelCase = camelCase;
 exports.castArray = castArray;
+exports.ceil = ceil;
 exports.chunk = chunk;
 exports.concat = concat;
 exports.conforms = conforms;
@@ -1180,6 +1486,7 @@ exports.findLastIndex = findLastIndex;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.flattenDepth = flattenDepth;
+exports.floor = floor;
 exports.fromPairs = fromPairs;
 exports.get = get;
 exports.has = has;
@@ -1188,16 +1495,20 @@ exports.isArguments = isArguments;
 exports.isArray = isArray;
 exports.isArrayLike = isArrayLike;
 exports.isBoolean = isBoolean;
+exports.isInteger = isInteger;
 exports.isMatch = isMatch;
 exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;
 exports.isRegExp = isRegExp;
+exports.isSafeInteger = isSafeInteger;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isTypedArray = isTypedArray;
 exports.isWeakMap = isWeakMap;
 exports.isWeakSet = isWeakSet;
 exports.join = join;
+exports.kebabCase = kebabCase;
+exports.lowerCase = lowerCase;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.matches = matches;
@@ -1206,18 +1517,29 @@ exports.max = max;
 exports.merge = merge;
 exports.mergeWith = mergeWith;
 exports.min = min;
+exports.omit = omit;
 exports.orderBy = orderBy;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.parseInt = parseInt;
+exports.pick = pick;
 exports.property = property;
 exports.rearg = rearg;
 exports.repeat = repeat;
 exports.rest = rest;
+exports.round = round;
 exports.set = set;
 exports.size = size;
+exports.snakeCase = snakeCase;
 exports.some = some;
 exports.sortBy = sortBy;
 exports.spread = spread;
+exports.startCase = startCase;
 exports.startsWith = startsWith;
+exports.toPath = toPath;
+exports.toString = toString;
+exports.trim = trim;
+exports.trimEnd = trimEnd;
+exports.trimStart = trimStart;
+exports.unset = unset;
 exports.zipObjectDeep = zipObjectDeep;