es-toolkit 1.15.1 → 1.16.0

package/dist/compat/index.js

@@ -2,13 +2,13 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const initial = require('../_chunk/initial-CBsbzo.js');
+const initial = require('../_chunk/initial-y0QrPY.js');
 const promise_index = require('../_chunk/index-CwRt_M.js');
 const function_index = require('../function/index.js');
 const math_index = require('../math/index.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const isObjectLike = require('../_chunk/isObjectLike-BeLCsr.js');
-const isFunction = require('../_chunk/isFunction-D0hq6d.js');
+const toMerged = require('../_chunk/toMerged-BGwYW5.js');
+const isFunction = require('../_chunk/isFunction-aCEz9d.js');
 const isTypedArray$1 = require('../_chunk/isTypedArray-BBEkFl.js');
 const string_index = require('../string/index.js');
 
@@ -42,6 +42,354 @@ function fill(array, value, start = 0, end = array.length) {
     return initial.fill(array, value, start, end);
 }
 
+const IS_PLAIN = /^\w*$/;
+const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+    switch (typeof key) {
+        case 'number':
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+        }
+    }
+}
+
+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)) {
+        return '-0';
+    }
+    return `${value}`;
+}
+
+function toPath(deepKey) {
+    const ESCAPE_REGEXP = /\\(\\)?/g;
+    const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
+        '|' +
+        '\\[(?:' +
+        '([^"\'][^[]*)' +
+        '|' +
+        '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+        ')\\]' +
+        '|' +
+        '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
+    const result = [];
+    if (deepKey[0] === '.') {
+        result.push('');
+    }
+    let match;
+    let lastIndex = 0;
+    while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+        let key = match[0];
+        const expr = match[1];
+        const quote = match[2];
+        const substr = match[3];
+        if (quote) {
+            key = substr.replace(ESCAPE_REGEXP, '$1');
+        }
+        else if (expr) {
+            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);
+    }
+    else {
+        resolvedPath = [path];
+    }
+    if (resolvedPath.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];
+    }
+    if (current === null && index === resolvedPath.length) {
+        return current;
+    }
+    return current ?? defaultValue;
+}
+
+function property(path) {
+    return function (object) {
+        return get(object, 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;
+    }
+    switch (typeof source) {
+        case 'object': {
+            if (source == null) {
+                return true;
+            }
+            const keys = Object.keys(source);
+            if (target == null) {
+                if (keys.length === 0) {
+                    return true;
+                }
+                return false;
+            }
+            if (Array.isArray(source)) {
+                return isArrayMatch(target, source);
+            }
+            if (source instanceof Map) {
+                return isMapMatch(target, source);
+            }
+            if (source instanceof Set) {
+                return isSetMatch(target, source);
+            }
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
+                    return false;
+                }
+                if (source[key] === undefined && target[key] !== undefined) {
+                    return false;
+                }
+                if (!isMatch(target[key], source[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 'function': {
+            if (Object.keys(source).length > 0) {
+                return isMatch(target, { ...source });
+            }
+            return false;
+        }
+        default: {
+            return !source;
+        }
+    }
+}
+
+function matches(source) {
+    source = toMerged.cloneDeep(source);
+    return (target) => {
+        return isMatch(target, source);
+    };
+}
+
+function cloneDeep(obj) {
+    if (typeof obj !== 'object') {
+        return toMerged.cloneDeep(obj);
+    }
+    switch (Object.prototype.toString.call(obj)) {
+        case isFunction.numberTag:
+        case isFunction.stringTag:
+        case isFunction.booleanTag: {
+            const result = new obj.constructor(obj?.valueOf());
+            toMerged.copyProperties(result, obj);
+            return result;
+        }
+        case isFunction.argumentsTag: {
+            const result = {};
+            toMerged.copyProperties(result, obj);
+            result.length = obj.length;
+            result[Symbol.iterator] = obj[Symbol.iterator];
+            return result;
+        }
+        default: {
+            return toMerged.cloneDeep(obj);
+        }
+    }
+}
+
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+    switch (typeof value) {
+        case 'number': {
+            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+        }
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return IS_UNSIGNED_INTEGER.test(value);
+        }
+    }
+}
+
+function isArguments(value) {
+    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
+}
+
+function has(object, path) {
+    let resolvedPath;
+    if (Array.isArray(path)) {
+        resolvedPath = path;
+    }
+    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
+        resolvedPath = toPath(path);
+    }
+    else {
+        resolvedPath = [path];
+    }
+    if (resolvedPath.length === 0) {
+        return false;
+    }
+    let current = object;
+    for (let i = 0; i < resolvedPath.length; i++) {
+        const key = resolvedPath[i];
+        if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {
+            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+            if (!isSparseIndex) {
+                return false;
+            }
+        }
+        current = current[key];
+    }
+    return true;
+}
+
+function matchesProperty(property, source) {
+    property = Array.isArray(property) ? property : toKey(property);
+    source = cloneDeep(source);
+    return function (target) {
+        const result = get(target, property);
+        if (result === undefined) {
+            return has(target, property);
+        }
+        if (source === undefined) {
+            return result === undefined;
+        }
+        return isMatch(result, source);
+    };
+}
+
+function find(source, doesMatch) {
+    let values = source;
+    if (!Array.isArray(source)) {
+        values = Object.values(source);
+    }
+    switch (typeof doesMatch) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const entries = Object.entries(source);
+                for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    const key = entry[0];
+                    const value = entry[1];
+                    if (doesMatch(value, key, source)) {
+                        return value;
+                    }
+                }
+                return undefined;
+            }
+            return values.find(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return values.find(matchesProperty(key, value));
+            }
+            else {
+                return values.find(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return values.find(property(doesMatch));
+        }
+    }
+}
+
+function findIndex(source, doesMatch) {
+    switch (typeof doesMatch) {
+        case 'function': {
+            return source.findIndex(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return source.findIndex(matchesProperty(key, value));
+            }
+            else {
+                return source.findIndex(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return source.findIndex(property(doesMatch));
+        }
+    }
+}
+
 function flatten(value, depth = 1) {
     const result = [];
     const flooredDepth = Math.floor(depth);
@@ -78,10 +426,6 @@ function flattenDepth(value, depth = 1) {
     return flatten(value, depth);
 }
 
-function isSymbol(value) {
-    return typeof value === 'symbol' || (value != null && value instanceof Symbol);
-}
-
 const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 const regexIsPlainProp = /^\w*$/;
 function isKey(value, object) {
@@ -95,45 +439,6 @@ function isKey(value, object) {
         (object != null && Object.hasOwn(object, value)));
 }
 
-function toPath(deepKey) {
-    const ESCAPE_REGEXP = /\\(\\)?/g;
-    const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
-        '|' +
-        '\\[(?:' +
-        '([^"\'][^[]*)' +
-        '|' +
-        '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
-        ')\\]' +
-        '|' +
-        '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
-    const result = [];
-    if (deepKey[0] === '.') {
-        result.push('');
-    }
-    let match;
-    let lastIndex = 0;
-    while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
-        let key = match[0];
-        const expr = match[1];
-        const quote = match[2];
-        const substr = match[3];
-        if (quote) {
-            key = substr.replace(ESCAPE_REGEXP, '$1');
-        }
-        else if (expr) {
-            key = expr;
-        }
-        result.push(key);
-        if (PROPERTY_REGEXP.lastIndex === lastIndex) {
-            PROPERTY_REGEXP.lastIndex++;
-        }
-        else {
-            lastIndex = PROPERTY_REGEXP.lastIndex;
-        }
-    }
-    return result;
-}
-
 function getPath(key, object) {
     if (Array.isArray(key)) {
         const path = [];
@@ -213,27 +518,8 @@ function size(target) {
     return Object.keys(target).length;
 }
 
-const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
-function isIndex(value) {
-    switch (typeof value) {
-        case 'number': {
-            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
-        }
-        case 'symbol': {
-            return false;
-        }
-        case 'string': {
-            return IS_UNSIGNED_INTEGER.test(value);
-        }
-    }
-}
-
 function set(obj, path, value) {
-    const resolvedPath = Array.isArray(path)
-        ? path
-        : typeof path === 'string'
-            ? toPath(path)
-            : [path];
+    const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
     for (let i = 0; i < resolvedPath.length - 1; i++) {
         const key = resolvedPath[i];
@@ -260,6 +546,25 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
+function indexOf(array, searchElement, fromIndex) {
+    if (array == null) {
+        return -1;
+    }
+    if (Number.isNaN(searchElement)) {
+        fromIndex = fromIndex ?? 0;
+        if (fromIndex < 0) {
+            fromIndex = Math.max(0, array.length + fromIndex);
+        }
+        for (let i = fromIndex; i < array.length; i++) {
+            if (Number.isNaN(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    return array.indexOf(searchElement, fromIndex);
+}
+
 function ary(func, n = func.length, guard) {
     if (guard) {
         n = func.length;
@@ -296,53 +601,12 @@ function bind(func, thisObj, ...partialArgs) {
 const bindPlaceholder = Symbol('bind.placeholder');
 bind.placeholder = bindPlaceholder;
 
-const IS_PLAIN = /^\w*$/;
-const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
-function isDeepKey(key) {
-    switch (typeof key) {
-        case 'number':
-        case 'symbol': {
-            return false;
-        }
-        case 'string': {
-            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
-        }
-    }
-}
-
-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);
-    }
-    else {
-        resolvedPath = [path];
-    }
-    if (resolvedPath.length === 0) {
-        return defaultValue;
-    }
-    let current = object;
-    let index;
-    for (index = 0; index < resolvedPath.length && current != null; index++) {
-        let key = resolvedPath[index];
-        if (Object.is(key.valueOf(), -0)) {
-            key = '-0';
-        }
-        current = current[key];
+function rest(func, start = func.length - 1) {
+    start = Number.parseInt(start, 10);
+    if (Number.isNaN(start) || start < 0) {
+        start = func.length - 1;
     }
-    if (current === null && index === resolvedPath.length) {
-        return current;
-    }
-    return current ?? defaultValue;
-}
-
-function property(path) {
-    return function (object) {
-        return get(object, path);
-    };
+    return function_index.rest(func, start);
 }
 
 function identity(x) {
@@ -356,10 +620,10 @@ function mapKeys(object, getNewKey) {
         case 'symbol':
         case 'number':
         case 'object': {
-            return isObjectLike.mapKeys(object, property(getNewKey));
+            return toMerged.mapKeys(object, property(getNewKey));
         }
         case 'function': {
-            return isObjectLike.mapKeys(object, getNewKey);
+            return toMerged.mapKeys(object, getNewKey);
         }
     }
 }
@@ -371,18 +635,14 @@ function mapValues(object, getNewValue) {
         case 'symbol':
         case 'number':
         case 'object': {
-            return isObjectLike.mapValues(object, property(getNewValue));
+            return toMerged.mapValues(object, property(getNewValue));
         }
         case 'function': {
-            return isObjectLike.mapValues(object, getNewValue);
+            return toMerged.mapValues(object, getNewValue);
         }
     }
 }
 
-function isArguments(value) {
-    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
-}
-
 function isPlainObject(object) {
     if (typeof object !== 'object') {
         return false;
@@ -415,31 +675,6 @@ function isTypedArray(x) {
     return isTypedArray$1.isTypedArray(x);
 }
 
-function cloneDeep(obj) {
-    if (typeof obj !== 'object') {
-        return isObjectLike.cloneDeep(obj);
-    }
-    switch (Object.prototype.toString.call(obj)) {
-        case isFunction.numberTag:
-        case isFunction.stringTag:
-        case isFunction.booleanTag: {
-            const result = new obj.constructor(obj?.valueOf());
-            isObjectLike.copyProperties(result, obj);
-            return result;
-        }
-        case isFunction.argumentsTag: {
-            const result = {};
-            isObjectLike.copyProperties(result, obj);
-            result.length = obj.length;
-            result[Symbol.iterator] = obj[Symbol.iterator];
-            return result;
-        }
-        default: {
-            return isObjectLike.cloneDeep(obj);
-        }
-    }
-}
-
 function mergeWith(object, ...otherArgs) {
     const sources = otherArgs.slice(0, -1);
     const merge = otherArgs[otherArgs.length - 1];
@@ -455,7 +690,7 @@ function mergeWithDeep(target, source, merge, stack) {
         return target;
     }
     if (stack.has(source)) {
-        return isObjectLike.clone(stack.get(source));
+        return toMerged.clone(stack.get(source));
     }
     stack.set(source, target);
     if (Array.isArray(source)) {
@@ -488,12 +723,9 @@ function mergeWithDeep(target, source, merge, stack) {
         else if (Array.isArray(sourceValue)) {
             target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
         }
-        else if (isObjectLike.isObjectLike(targetValue) && isObjectLike.isObjectLike(sourceValue)) {
+        else if (toMerged.isObjectLike(targetValue) && toMerged.isObjectLike(sourceValue)) {
             target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
         }
-        else if (targetValue == null && Array.isArray(sourceValue)) {
-            target[key] = mergeWithDeep([], sourceValue, merge, stack);
-        }
         else if (targetValue == null && isPlainObject(sourceValue)) {
             target[key] = mergeWithDeep({}, sourceValue, merge, stack);
         }
@@ -516,8 +748,7 @@ function isArray(value) {
 }
 
 function isArrayLike(value) {
-    return value != null && typeof value !== "function" &&
-        isFunction.isLength(value.length);
+    return value != null && typeof value !== 'function' && isFunction.isLength(value.length);
 }
 
 function isBoolean(x) {
@@ -530,108 +761,14 @@ function isBoolean(x) {
     return false;
 }
 
-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) {
+function isString(value) {
+    if (typeof value === 'string') {
         return true;
     }
-    if (!(target instanceof Set)) {
-        return false;
-    }
-    return isArrayMatch([...target], [...source]);
-}
-
-function isMatch(target, source) {
-    if (source === target) {
+    if (typeof value === 'object' && value != null && isFunction.getTag(value) === '[object String]') {
         return true;
     }
-    switch (typeof source) {
-        case 'object': {
-            if (source == null) {
-                return true;
-            }
-            const keys = Object.keys(source);
-            if (target == null) {
-                if (keys.length === 0) {
-                    return true;
-                }
-                return false;
-            }
-            if (Array.isArray(source)) {
-                return isArrayMatch(target, source);
-            }
-            if (source instanceof Map) {
-                return isMapMatch(target, source);
-            }
-            if (source instanceof Set) {
-                return isSetMatch(target, source);
-            }
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
-                    return false;
-                }
-                if (source[key] === undefined && target[key] !== undefined) {
-                    return false;
-                }
-                if (!isMatch(target[key], source[key])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        case 'function': {
-            if (Object.keys(source).length > 0) {
-                return isMatch(target, { ...source });
-            }
-            return false;
-        }
-        default: {
-            return !source;
-        }
-    }
-}
-
-function matches(source) {
-    source = isObjectLike.cloneDeep(source);
-    return (target) => {
-        return isMatch(target, source);
-    };
+    return false;
 }
 
 const startsWith = (str, target, position = 0) => {
@@ -646,6 +783,10 @@ function padStart(str, length = 0, chars = ' ') {
     return str.padStart(length, chars);
 }
 
+function padEnd(str, length = 0, chars = ' ') {
+    return str.padEnd(length, chars);
+}
+
 function max(items = []) {
     let maxElement = items[0];
     let max = undefined;
@@ -696,6 +837,7 @@ exports.partition = initial.partition;
 exports.sample = initial.sample;
 exports.sampleSize = initial.sampleSize;
 exports.shuffle = initial.shuffle;
+exports.sortBy = initial.sortBy;
 exports.tail = initial.tail;
 exports.take = initial.take;
 exports.takeRight = initial.takeRight;
@@ -724,9 +866,12 @@ exports.withTimeout = promise_index.withTimeout;
 exports.after = function_index.after;
 exports.before = function_index.before;
 exports.debounce = function_index.debounce;
+exports.memoize = function_index.memoize;
 exports.negate = function_index.negate;
 exports.noop = function_index.noop;
 exports.once = function_index.once;
+exports.partial = function_index.partial;
+exports.partialRight = function_index.partialRight;
 exports.throttle = function_index.throttle;
 exports.unary = function_index.unary;
 exports.clamp = math_index.clamp;
@@ -739,15 +884,16 @@ exports.sum = math_index.sum;
 exports.sumBy = math_index.sumBy;
 exports.random = randomInt.random;
 exports.randomInt = randomInt.randomInt;
-exports.clone = isObjectLike.clone;
-exports.cloneDeep = isObjectLike.cloneDeep;
-exports.flattenObject = isObjectLike.flattenObject;
-exports.invert = isObjectLike.invert;
-exports.isObjectLike = isObjectLike.isObjectLike;
-exports.omit = isObjectLike.omit;
-exports.omitBy = isObjectLike.omitBy;
-exports.pick = isObjectLike.pick;
-exports.pickBy = isObjectLike.pickBy;
+exports.clone = toMerged.clone;
+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.isEqual = isFunction.isEqual;
 exports.isFunction = isFunction.isFunction;
 exports.isLength = isFunction.isLength;
@@ -770,28 +916,36 @@ exports.concat = concat;
 exports.difference = difference;
 exports.endsWith = endsWith;
 exports.fill = fill;
+exports.find = find;
+exports.findIndex = findIndex;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.flattenDepth = flattenDepth;
 exports.get = get;
+exports.has = has;
+exports.indexOf = indexOf;
 exports.isArguments = isArguments;
 exports.isArray = isArray;
 exports.isArrayLike = isArrayLike;
 exports.isBoolean = isBoolean;
 exports.isMatch = isMatch;
 exports.isPlainObject = isPlainObject;
+exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isTypedArray = isTypedArray;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.matches = matches;
+exports.matchesProperty = matchesProperty;
 exports.max = max;
 exports.merge = merge;
 exports.mergeWith = mergeWith;
 exports.min = min;
 exports.orderBy = orderBy;
+exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.property = property;
+exports.rest = rest;
 exports.set = set;
 exports.size = size;
 exports.startsWith = startsWith;