es-toolkit 1.23.0-dev.743 → 1.23.0-dev.745

package/dist/compat/index.js

@@ -6,12 +6,12 @@ const zipWith = require('../_chunk/zipWith-EOU_KZ.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
 const flowRight$1 = require('../_chunk/flowRight-Cf9ldK.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
-const rangeRight = require('../_chunk/rangeRight-CtcxMd.js');
+const sumBy = require('../_chunk/sumBy-BkErWJ.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const isObjectLike = require('../_chunk/isObjectLike-aywuSF.js');
+const toMerged = require('../_chunk/toMerged-BBJZIl.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-DgrsU7.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-CjpFwn.js');
-const pad$1 = require('../_chunk/pad-BWiShN.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-Bd6nry.js');
+const upperFirst = require('../_chunk/upperFirst-BUECmK.js');
 
 function castArray(value) {
     if (arguments.length === 0) {
@@ -272,7 +272,7 @@ function isSetMatch(target, source) {
 }
 
 function matches(source) {
-    source = isObjectLike.cloneDeep(source);
+    source = toMerged.cloneDeep(source);
     return (target) => {
         return isMatch(target, source);
     };
@@ -280,25 +280,25 @@ function matches(source) {
 
 function cloneDeep(obj) {
     if (typeof obj !== 'object') {
-        return isObjectLike.cloneDeep(obj);
+        return toMerged.cloneDeep(obj);
     }
     switch (Object.prototype.toString.call(obj)) {
         case isWeakSet$1.numberTag:
         case isWeakSet$1.stringTag:
         case isWeakSet$1.booleanTag: {
             const result = new obj.constructor(obj?.valueOf());
-            isObjectLike.copyProperties(result, obj);
+            toMerged.copyProperties(result, obj);
             return result;
         }
         case isWeakSet$1.argumentsTag: {
             const result = {};
-            isObjectLike.copyProperties(result, obj);
+            toMerged.copyProperties(result, obj);
             result.length = obj.length;
             result[Symbol.iterator] = obj[Symbol.iterator];
             return result;
         }
         default: {
-            return isObjectLike.cloneDeep(obj);
+            return toMerged.cloneDeep(obj);
         }
     }
 }
@@ -456,6 +456,43 @@ function fill(array, value, start = 0, end = array.length) {
     return zipWith.fill(array, value, start, end);
 }
 
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+function filter(source, predicate) {
+    if (!predicate) {
+        predicate = identity;
+    }
+    const collection = isArray(source) ? source : Object.values(source);
+    switch (typeof predicate) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const result = [];
+                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 (predicate(value, key, source)) {
+                        result.push(value);
+                    }
+                }
+                return result;
+            }
+            return collection.filter(predicate);
+        }
+        case 'object': {
+            return isArray(predicate)
+                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
+                : collection.filter(matches(predicate));
+        }
+        case 'string': {
+            return collection.filter(property(predicate));
+        }
+    }
+}
+
 function find(source, doesMatch) {
     let values = source;
     if (!Array.isArray(source)) {
@@ -787,10 +824,6 @@ function orderBy(collection, criteria, orders) {
         .map(item => item.original);
 }
 
-function sortBy(collection, criteria) {
-    return orderBy(collection, criteria, ['asc']);
-}
-
 function size(target) {
     if (isWeakSet$1.isNil(target)) {
         return 0;
@@ -831,6 +864,10 @@ function some(arr, predicate, guard) {
     }
 }
 
+function sortBy(collection, criteria) {
+    return orderBy(collection, criteria, ['asc']);
+}
+
 function take(arr, count) {
     if (count < 1) {
         return [];
@@ -866,43 +903,6 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
-function isArray(value) {
-    return Array.isArray(value);
-}
-
-function filter(source, predicate) {
-    if (!predicate) {
-        predicate = identity;
-    }
-    const collection = isArray(source) ? source : Object.values(source);
-    switch (typeof predicate) {
-        case 'function': {
-            if (!Array.isArray(source)) {
-                const result = [];
-                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 (predicate(value, key, source)) {
-                        result.push(value);
-                    }
-                }
-                return result;
-            }
-            return collection.filter(predicate);
-        }
-        case 'object': {
-            return isArray(predicate)
-                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
-                : collection.filter(matches(predicate));
-        }
-        case 'string': {
-            return collection.filter(property(predicate));
-        }
-    }
-}
-
 function ary(func, n = func.length, guard) {
     if (guard) {
         n = func.length;
@@ -913,6 +913,32 @@ function ary(func, n = func.length, guard) {
     return flowRight$1.ary(func, n);
 }
 
+function attempt(func, ...args) {
+    try {
+        return func(...args);
+    }
+    catch (e) {
+        return e instanceof Error ? e : new Error(e);
+    }
+}
+
+function before(n, func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    let result;
+    n = toInteger(n);
+    return function (...args) {
+        if (--n > 0) {
+            result = func.apply(this, args);
+        }
+        if (n <= 1 && func) {
+            func = undefined;
+        }
+        return result;
+    };
+}
+
 function bind(func, thisObj, ...partialArgs) {
     const bound = function (...providedArgs) {
         const args = [];
@@ -939,23 +965,6 @@ function bind(func, thisObj, ...partialArgs) {
 const bindPlaceholder = Symbol('bind.placeholder');
 bind.placeholder = bindPlaceholder;
 
-function before(n, func) {
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    let result;
-    n = toInteger(n);
-    return function (...args) {
-        if (--n > 0) {
-            result = func.apply(this, args);
-        }
-        if (n <= 1 && func) {
-            func = undefined;
-        }
-        return result;
-    };
-}
-
 function bindKey(object, key, ...partialArgs) {
     const bound = function (...providedArgs) {
         const args = [];
@@ -982,56 +991,6 @@ function bindKey(object, key, ...partialArgs) {
 const bindKeyPlaceholder = Symbol('bindKey.placeholder');
 bindKey.placeholder = bindKeyPlaceholder;
 
-function defer(func, ...args) {
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    return setTimeout(func, 1, ...args);
-}
-
-function rest(func, start = func.length - 1) {
-    start = Number.parseInt(start, 10);
-    if (Number.isNaN(start) || start < 0) {
-        start = func.length - 1;
-    }
-    return flowRight$1.rest(func, start);
-}
-
-function spread(func, argsIndex = 0) {
-    argsIndex = Number.parseInt(argsIndex, 10);
-    if (Number.isNaN(argsIndex) || argsIndex < 0) {
-        argsIndex = 0;
-    }
-    return function (...args) {
-        const array = args[argsIndex];
-        const params = args.slice(0, argsIndex);
-        if (array) {
-            params.push(...array);
-        }
-        return func.apply(this, params);
-    };
-}
-
-function attempt(func, ...args) {
-    try {
-        return func(...args);
-    }
-    catch (e) {
-        return e instanceof Error ? e : new Error(e);
-    }
-}
-
-function rearg(func, ...indices) {
-    const flattenIndices = flatten(indices);
-    return function (...args) {
-        const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length);
-        for (let i = reorderedArgs.length; i < args.length; i++) {
-            reorderedArgs.push(args[i]);
-        }
-        return func.apply(this, reorderedArgs);
-    };
-}
-
 function curry(func, arity = func.length, guard) {
     arity = guard ? func.length : arity;
     arity = Number.parseInt(arity, 10);
@@ -1196,12 +1155,11 @@ function debounce(func, debounceMs = 0, options = {}) {
     return debounced;
 }
 
-function throttle(func, throttleMs = 0, options = {}) {
-    if (typeof options !== 'object') {
-        options = {};
+function defer(func, ...args) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
     }
-    const { leading = true, trailing = true, signal } = options;
-    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+    return setTimeout(func, 1, ...args);
 }
 
 function flip(func) {
@@ -1226,130 +1184,262 @@ function flowRight(...funcs) {
     return flowRight$1.flowRight(...flattenFuncs);
 }
 
-function isNil(x) {
-    return x == null;
+function rearg(func, ...indices) {
+    const flattenIndices = flatten(indices);
+    return function (...args) {
+        const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length);
+        for (let i = reorderedArgs.length; i < args.length; i++) {
+            reorderedArgs.push(args[i]);
+        }
+        return func.apply(this, reorderedArgs);
+    };
 }
 
-function pick(obj, ...keysArr) {
-    if (isNil(obj)) {
-        return {};
+function rest(func, start = func.length - 1) {
+    start = Number.parseInt(start, 10);
+    if (Number.isNaN(start) || start < 0) {
+        start = func.length - 1;
     }
-    const result = {};
-    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);
-                }
-                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.hasOwn(obj, key)) {
-                result[key] = value;
-            }
-            else {
-                set(result, key, value);
-            }
-        }
+    return flowRight$1.rest(func, start);
+}
+
+function spread(func, argsIndex = 0) {
+    argsIndex = Number.parseInt(argsIndex, 10);
+    if (Number.isNaN(argsIndex) || argsIndex < 0) {
+        argsIndex = 0;
     }
-    return result;
+    return function (...args) {
+        const array = args[argsIndex];
+        const params = args.slice(0, argsIndex);
+        if (array) {
+            params.push(...array);
+        }
+        return func.apply(this, params);
+    };
 }
 
-function unset(obj, path) {
-    if (obj == null) {
-        return true;
+function throttle(func, throttleMs = 0, options = {}) {
+    if (typeof options !== 'object') {
+        options = {};
     }
-    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);
-                }
+    const { leading = true, trailing = true, signal } = options;
+    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+}
+
+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 clamp(value, bound1, bound2) {
+    if (Number.isNaN(bound1)) {
+        bound1 = 0;
+    }
+    if (Number.isNaN(bound2)) {
+        bound2 = 0;
+    }
+    return sumBy.clamp(value, bound1, bound2);
+}
+
+function floor(number, precision = 0) {
+    return decimalAdjust('floor', number, precision);
+}
+
+function inRange(value, minimum, maximum) {
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (maximum != null && !maximum) {
+        maximum = 0;
+    }
+    if (minimum != null && typeof minimum !== 'number') {
+        minimum = Number(minimum);
+    }
+    if (maximum == null && minimum === 0) {
+        return false;
+    }
+    if (maximum != null && typeof maximum !== 'number') {
+        maximum = Number(maximum);
+    }
+    if (maximum != null && minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    if (minimum === maximum) {
+        return false;
+    }
+    return sumBy.inRange(value, minimum, maximum);
+}
+
+function max(items = []) {
+    let maxElement = items[0];
+    let max = undefined;
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
+        if (max == null || element > max) {
+            max = element;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}
+
+function min(items = []) {
+    let minElement = items[0];
+    let min = undefined;
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
+        if (min == null || element < min) {
+            min = element;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+function parseInt(string, radix = 0, guard) {
+    if (guard) {
+        radix = 0;
+    }
+    return Number.parseInt(string, radix);
+}
+
+function random(...args) {
+    let minimum = 0;
+    let maximum = 1;
+    let floating = false;
+    switch (args.length) {
+        case 1: {
+            if (typeof args[0] === 'boolean') {
+                floating = args[0];
             }
-            if (obj?.[path] === undefined) {
-                return true;
+            else {
+                maximum = args[0];
             }
-            try {
-                delete obj[path];
-                return true;
+            break;
+        }
+        case 2: {
+            if (typeof args[1] === 'boolean') {
+                maximum = args[0];
+                floating = args[1];
             }
-            catch {
-                return false;
+            else {
+                minimum = args[0];
+                maximum = args[1];
             }
         }
-        case 'string': {
-            if (obj?.[path] === undefined && isDeepKey(path)) {
-                return unsetWithPath(obj, toPath(path));
-            }
-            try {
-                delete obj[path];
-                return true;
+        case 3: {
+            if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) {
+                minimum = 0;
+                maximum = args[0];
+                floating = false;
             }
-            catch {
-                return false;
+            else {
+                minimum = args[0];
+                maximum = args[1];
+                floating = args[2];
             }
         }
     }
-}
-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;
+    if (typeof minimum !== 'number') {
+        minimum = Number(minimum);
     }
-    try {
-        delete parent[lastKey];
-        return true;
+    if (typeof maximum !== 'number') {
+        minimum = Number(maximum);
     }
-    catch {
-        return false;
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (!maximum) {
+        maximum = 0;
+    }
+    if (minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    if (minimum === maximum) {
+        return minimum;
+    }
+    if (floating) {
+        return randomInt.random(minimum, maximum + 1);
+    }
+    else {
+        return randomInt.randomInt(minimum, maximum + 1);
     }
 }
 
-function omit(obj, ...keysArr) {
-    if (obj == null) {
+function round(number, precision = 0) {
+    return decimalAdjust('round', number, precision);
+}
+
+function defaults(object, ...sources) {
+    object = Object(object);
+    const objectProto = Object.prototype;
+    for (let i = 0; i < sources.length; i++) {
+        const source = sources[i];
+        const keys = Object.keys(source);
+        for (let j = 0; j < keys.length; j++) {
+            const key = keys[j];
+            const value = object[key];
+            if (value === undefined ||
+                (!Object.hasOwn(object, key) && isWeakSet$1.eq(value, objectProto[key]))) {
+                object[key] = source[key];
+            }
+        }
+    }
+    return object;
+}
+
+function isArrayLike(value) {
+    return value != null && typeof value !== 'function' && isWeakSet$1.isLength(value.length);
+}
+
+function fromPairs(pairs) {
+    if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
         return {};
     }
-    const result = isObjectLike.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;
-            }
+    const result = {};
+    for (const [key, value] of pairs) {
+        result[key] = value;
+    }
+    return result;
+}
+
+function invertBy(object, iteratee) {
+    const result = {};
+    if (isWeakSet$1.isNil(object)) {
+        return result;
+    }
+    if (iteratee == null) {
+        iteratee = identity;
+    }
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        const valueStr = iteratee(value);
+        if (Array.isArray(result[valueStr])) {
+            result[valueStr].push(key);
+        }
+        else {
+            result[valueStr] = [key];
         }
     }
     return result;
@@ -1362,10 +1452,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);
         }
     }
 }
@@ -1377,10 +1467,10 @@ 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);
         }
     }
 }
@@ -1432,7 +1522,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)) {
@@ -1476,7 +1566,7 @@ 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 && isPlainObject(sourceValue)) {
@@ -1496,60 +1586,133 @@ function merge(object, ...sources) {
     return mergeWith(object, ...sources, noop.noop);
 }
 
-function isArrayLike(value) {
-    return value != null && typeof value !== 'function' && isWeakSet$1.isLength(value.length);
+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 fromPairs(pairs) {
-    if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
-        return {};
+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;
     }
-    const result = {};
-    for (const [key, value] of pairs) {
-        result[key] = value;
+    try {
+        delete parent[lastKey];
+        return true;
+    }
+    catch {
+        return false;
     }
-    return result;
 }
 
-function invertBy(object, iteratee) {
-    const result = {};
-    if (isWeakSet$1.isNil(object)) {
-        return result;
-    }
-    if (iteratee == null) {
-        iteratee = identity;
+function omit(obj, ...keysArr) {
+    if (obj == null) {
+        return {};
     }
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        const valueStr = iteratee(value);
-        if (Array.isArray(result[valueStr])) {
-            result[valueStr].push(key);
-        }
-        else {
-            result[valueStr] = [key];
+    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 defaults(object, ...sources) {
-    object = Object(object);
-    const objectProto = Object.prototype;
-    for (let i = 0; i < sources.length; i++) {
-        const source = sources[i];
-        const keys = Object.keys(source);
-        for (let j = 0; j < keys.length; j++) {
-            const key = keys[j];
-            const value = object[key];
-            if (value === undefined ||
-                (!Object.hasOwn(object, key) && isWeakSet$1.eq(value, objectProto[key]))) {
-                object[key] = source[key];
+function isNil(x) {
+    return x == null;
+}
+
+function pick(obj, ...keysArr) {
+    if (isNil(obj)) {
+        return {};
+    }
+    const result = {};
+    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);
+                }
+                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.hasOwn(obj, key)) {
+                result[key] = value;
+            }
+            else {
+                set(result, key, value);
             }
         }
     }
-    return object;
+    return result;
 }
 
 function toDefaulted(object, ...sources) {
@@ -1557,42 +1720,6 @@ function toDefaulted(object, ...sources) {
     return defaults(cloned, ...sources);
 }
 
-function isArrayBuffer(value) {
-    return isWeakSet$1.isArrayBuffer(value);
-}
-
-function isBoolean(value) {
-    return typeof value === 'boolean' || value instanceof Boolean;
-}
-
-function isError(value) {
-    return isWeakSet$1.getTag(value) === '[object Error]';
-}
-
-function isFinite(value) {
-    return Number.isFinite(value);
-}
-
-function isMap(value) {
-    return isWeakSet$1.isMap(value);
-}
-
-function isSet(value) {
-    return isWeakSet$1.isSet(value);
-}
-
-function isRegExp(value) {
-    return isWeakSet$1.isRegExp(value);
-}
-
-function isWeakMap(value) {
-    return isWeakSet$1.isWeakMap(value);
-}
-
-function isWeakSet(value) {
-    return isWeakSet$1.isWeakSet(value);
-}
-
 function conformsTo(target, source) {
     if (source == null) {
         return true;
@@ -1613,48 +1740,84 @@ function conformsTo(target, source) {
 }
 
 function conforms(source) {
-    source = isObjectLike.cloneDeep(source);
+    source = toMerged.cloneDeep(source);
     return function (object) {
         return conformsTo(object, source);
     };
 }
 
+function isArrayBuffer(value) {
+    return isWeakSet$1.isArrayBuffer(value);
+}
+
+function isArrayLikeObject(value) {
+    return toMerged.isObjectLike(value) && isArrayLike(value);
+}
+
+function isBoolean(value) {
+    return typeof value === 'boolean' || value instanceof Boolean;
+}
+
+function isEqualWith(a, b, areValuesEqual = noop.noop) {
+    if (typeof areValuesEqual !== 'function') {
+        areValuesEqual = noop.noop;
+    }
+    return isWeakSet$1.isEqualWith(a, b, (...args) => {
+        const result = areValuesEqual(...args);
+        if (result !== undefined) {
+            return !!result;
+        }
+        if (a instanceof Map && b instanceof Map) {
+            return isEqualWith(Array.from(a), Array.from(b), flowRight$1.after(2, areValuesEqual));
+        }
+        if (a instanceof Set && b instanceof Set) {
+            return isEqualWith(Array.from(a), Array.from(b), flowRight$1.after(2, areValuesEqual));
+        }
+    });
+}
+
+function isError(value) {
+    return isWeakSet$1.getTag(value) === '[object Error]';
+}
+
+function isFinite(value) {
+    return Number.isFinite(value);
+}
+
 function isInteger(value) {
     return Number.isInteger(value);
 }
 
-function isSafeInteger(value) {
-    return Number.isSafeInteger(value);
+function isMap(value) {
+    return isWeakSet$1.isMap(value);
+}
+
+function isNaN(value) {
+    return Number.isNaN(value);
 }
 
 function isNumber(value) {
     return typeof value === 'number' || value instanceof Number;
 }
 
-function isNaN(value) {
-    return Number.isNaN(value);
+function isRegExp(value) {
+    return isWeakSet$1.isRegExp(value);
 }
 
-function isArrayLikeObject(value) {
-    return isObjectLike.isObjectLike(value) && isArrayLike(value);
+function isSafeInteger(value) {
+    return Number.isSafeInteger(value);
 }
 
-function isEqualWith(a, b, areValuesEqual = noop.noop) {
-    if (typeof areValuesEqual !== 'function') {
-        areValuesEqual = noop.noop;
-    }
-    return isWeakSet$1.isEqualWith(a, b, (...args) => {
-        const result = areValuesEqual(...args);
-        if (result !== undefined) {
-            return !!result;
-        }
-        if (a instanceof Map && b instanceof Map) {
-            return isEqualWith(Array.from(a), Array.from(b), flowRight$1.after(2, areValuesEqual));
-        }
-        if (a instanceof Set && b instanceof Set) {
-            return isEqualWith(Array.from(a), Array.from(b), flowRight$1.after(2, areValuesEqual));
-        }
-    });
+function isSet(value) {
+    return isWeakSet$1.isSet(value);
+}
+
+function isWeakMap(value) {
+    return isWeakSet$1.isWeakMap(value);
+}
+
+function isWeakSet(value) {
+    return isWeakSet$1.isWeakSet(value);
 }
 
 function toString(value) {
@@ -1679,19 +1842,43 @@ function normalizeForCase(str) {
 }
 
 function camelCase(str) {
-    return pad$1.camelCase(normalizeForCase(str));
+    return upperFirst.camelCase(normalizeForCase(str));
+}
+
+function endsWith(str, target, position = str.length) {
+    return str.endsWith(target, position);
 }
 
 function kebabCase(str) {
-    return pad$1.kebabCase(normalizeForCase(str));
+    return upperFirst.kebabCase(normalizeForCase(str));
+}
+
+function lowerCase(str) {
+    return upperFirst.lowerCase(normalizeForCase(str));
+}
+
+function pad(str, length, chars = ' ') {
+    return upperFirst.pad(toString(str), length, chars);
+}
+
+function padEnd(str, length = 0, chars = ' ') {
+    return toString(str).padEnd(length, chars);
+}
+
+function padStart(str, length = 0, chars = ' ') {
+    return toString(str).padStart(length, chars);
+}
+
+function repeat(str, n) {
+    return str.repeat(n);
 }
 
 function snakeCase(str) {
-    return pad$1.snakeCase(normalizeForCase(str));
+    return upperFirst.snakeCase(normalizeForCase(str));
 }
 
 function startCase(str) {
-    const words = pad$1.getWords(normalizeForCase(str).trim());
+    const words = upperFirst.getWords(normalizeForCase(str).trim());
     let result = '';
     for (let i = 0; i < words.length; i++) {
         const word = words[i];
@@ -1708,36 +1895,12 @@ function startCase(str) {
     return result;
 }
 
-function lowerCase(str) {
-    return pad$1.lowerCase(normalizeForCase(str));
-}
-
-function upperCase(str) {
-    return pad$1.upperCase(normalizeForCase(str));
-}
-
 function startsWith(str, target, position = 0) {
     return str.startsWith(target, position);
 }
 
-function endsWith(str, target, position = str.length) {
-    return str.endsWith(target, position);
-}
-
-function pad(str, length, chars = ' ') {
-    return pad$1.pad(toString(str), length, chars);
-}
-
-function padStart(str, length = 0, chars = ' ') {
-    return toString(str).padStart(length, chars);
-}
-
-function padEnd(str, length = 0, chars = ' ') {
-    return toString(str).padEnd(length, chars);
-}
-
-function repeat(str, n) {
-    return str.repeat(n);
+function upperCase(str) {
+    return upperFirst.upperCase(normalizeForCase(str));
 }
 
 function trim(str, chars, guard) {
@@ -1749,228 +1912,77 @@ function trim(str, chars, guard) {
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trim(str, chars.toString().split(''));
+            return upperFirst.trim(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trim(str, chars.map(x => x.toString()));
+                return upperFirst.trim(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trim(str, chars.toString().split(''));
+                return upperFirst.trim(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function trimStart(str, chars, guard) {
+function trimEnd(str, chars, guard) {
     if (str == null) {
         return '';
     }
     if (guard != null || chars == null) {
-        return str.toString().trimStart();
+        return str.toString().trimEnd();
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trimStart(str, chars.toString().split(''));
+            return upperFirst.trimEnd(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trimStart(str, chars.map(x => x.toString()));
+                return upperFirst.trimEnd(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trimStart(str, chars.toString().split(''));
+                return upperFirst.trimEnd(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function trimEnd(str, chars, guard) {
+function trimStart(str, chars, guard) {
     if (str == null) {
         return '';
     }
     if (guard != null || chars == null) {
-        return str.toString().trimEnd();
+        return str.toString().trimStart();
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trimEnd(str, chars.toString().split(''));
+            return upperFirst.trimStart(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trimEnd(str, chars.map(x => x.toString()));
+                return upperFirst.trimStart(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trimEnd(str, chars.toString().split(''));
+                return upperFirst.trimStart(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function clamp(value, bound1, bound2) {
-    if (Number.isNaN(bound1)) {
-        bound1 = 0;
-    }
-    if (Number.isNaN(bound2)) {
-        bound2 = 0;
-    }
-    return rangeRight.clamp(value, bound1, bound2);
-}
-
-function max(items = []) {
-    let maxElement = items[0];
-    let max = undefined;
-    for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (max == null || element > max) {
-            max = element;
-            maxElement = element;
-        }
-    }
-    return maxElement;
-}
-
-function min(items = []) {
-    let minElement = items[0];
-    let min = undefined;
-    for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (min == null || element < min) {
-            min = element;
-            minElement = element;
-        }
-    }
-    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;
-    }
-    return Number.parseInt(string, radix);
-}
-
-function inRange(value, minimum, maximum) {
-    if (!minimum) {
-        minimum = 0;
-    }
-    if (maximum != null && !maximum) {
-        maximum = 0;
-    }
-    if (minimum != null && typeof minimum !== 'number') {
-        minimum = Number(minimum);
-    }
-    if (maximum == null && minimum === 0) {
-        return false;
-    }
-    if (maximum != null && typeof maximum !== 'number') {
-        maximum = Number(maximum);
-    }
-    if (maximum != null && minimum > maximum) {
-        [minimum, maximum] = [maximum, minimum];
-    }
-    if (minimum === maximum) {
-        return false;
-    }
-    return rangeRight.inRange(value, minimum, maximum);
+function constant(value) {
+    return () => value;
 }
 
-function random(...args) {
-    let minimum = 0;
-    let maximum = 1;
-    let floating = false;
-    switch (args.length) {
-        case 1: {
-            if (typeof args[0] === 'boolean') {
-                floating = args[0];
-            }
-            else {
-                maximum = args[0];
-            }
-            break;
-        }
-        case 2: {
-            if (typeof args[1] === 'boolean') {
-                maximum = args[0];
-                floating = args[1];
-            }
-            else {
-                minimum = args[0];
-                maximum = args[1];
-            }
-        }
-        case 3: {
-            if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) {
-                minimum = 0;
-                maximum = args[0];
-                floating = false;
-            }
-            else {
-                minimum = args[0];
-                maximum = args[1];
-                floating = args[2];
-            }
-        }
-    }
-    if (typeof minimum !== 'number') {
-        minimum = Number(minimum);
-    }
-    if (typeof maximum !== 'number') {
-        minimum = Number(maximum);
-    }
-    if (!minimum) {
-        minimum = 0;
-    }
-    if (!maximum) {
-        maximum = 0;
-    }
-    if (minimum > maximum) {
-        [minimum, maximum] = [maximum, minimum];
-    }
-    minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    if (minimum === maximum) {
-        return minimum;
-    }
-    if (floating) {
-        return randomInt.random(minimum, maximum + 1);
+function times(n, iteratee) {
+    n = toInteger(n);
+    if (n < 1 || !Number.isSafeInteger(n)) {
+        return [];
     }
-    else {
-        return randomInt.randomInt(minimum, maximum + 1);
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+        result[i] = typeof iteratee === 'function' ? iteratee(i) : i;
     }
-}
-
-function constant(value) {
-    return () => value;
+    return result;
 }
 
 exports.at = zipWith.at;
@@ -2033,20 +2045,20 @@ exports.partial = flowRight$1.partial;
 exports.partialRight = flowRight$1.partialRight;
 exports.unary = flowRight$1.unary;
 exports.noop = noop.noop;
-exports.mean = rangeRight.mean;
-exports.meanBy = rangeRight.meanBy;
-exports.range = rangeRight.range;
-exports.rangeRight = rangeRight.rangeRight;
-exports.sum = rangeRight.sum;
-exports.sumBy = rangeRight.sumBy;
+exports.mean = sumBy.mean;
+exports.meanBy = sumBy.meanBy;
+exports.range = sumBy.range;
+exports.rangeRight = sumBy.rangeRight;
+exports.sum = sumBy.sum;
+exports.sumBy = sumBy.sumBy;
 exports.randomInt = randomInt.randomInt;
-exports.clone = isObjectLike.clone;
-exports.flattenObject = isObjectLike.flattenObject;
-exports.invert = isObjectLike.invert;
-exports.isObjectLike = isObjectLike.isObjectLike;
-exports.omitBy = isObjectLike.omitBy;
-exports.pickBy = isObjectLike.pickBy;
-exports.toMerged = isObjectLike.toMerged;
+exports.clone = toMerged.clone;
+exports.flattenObject = toMerged.flattenObject;
+exports.invert = toMerged.invert;
+exports.isObjectLike = toMerged.isObjectLike;
+exports.omitBy = toMerged.omitBy;
+exports.pickBy = toMerged.pickBy;
+exports.toMerged = toMerged.toMerged;
 exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.eq = isWeakSet$1.eq;
 exports.isBlob = isWeakSet$1.isBlob;
@@ -2060,15 +2072,15 @@ exports.isLength = isWeakSet$1.isLength;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isUndefined = isWeakSet$1.isUndefined;
-exports.capitalize = pad$1.capitalize;
-exports.constantCase = pad$1.constantCase;
-exports.deburr = pad$1.deburr;
-exports.escape = pad$1.escape;
-exports.escapeRegExp = pad$1.escapeRegExp;
-exports.lowerFirst = pad$1.lowerFirst;
-exports.pascalCase = pad$1.pascalCase;
-exports.unescape = pad$1.unescape;
-exports.upperFirst = pad$1.upperFirst;
+exports.capitalize = upperFirst.capitalize;
+exports.constantCase = upperFirst.constantCase;
+exports.deburr = upperFirst.deburr;
+exports.escape = upperFirst.escape;
+exports.escapeRegExp = upperFirst.escapeRegExp;
+exports.lowerFirst = upperFirst.lowerFirst;
+exports.pascalCase = upperFirst.pascalCase;
+exports.unescape = upperFirst.unescape;
+exports.upperFirst = upperFirst.upperFirst;
 exports.ary = ary;
 exports.attempt = attempt;
 exports.before = before;
@@ -2172,6 +2184,7 @@ exports.startCase = startCase;
 exports.startsWith = startsWith;
 exports.take = take;
 exports.throttle = throttle;
+exports.times = times;
 exports.toDefaulted = toDefaulted;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;