es-toolkit 1.23.0 → 1.24.0

package/dist/compat/index.mjs

@@ -4,7 +4,6 @@ export { countBy } from '../array/countBy.mjs';
 export { differenceBy } from '../array/differenceBy.mjs';
 export { differenceWith } from '../array/differenceWith.mjs';
 export { dropRight } from '../array/dropRight.mjs';
-export { dropRightWhile } from '../array/dropRightWhile.mjs';
 export { flatMap } from '../array/flatMap.mjs';
 export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
@@ -25,7 +24,6 @@ export { sample } from '../array/sample.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
 export { tail } from '../array/tail.mjs';
-export { take } from '../array/take.mjs';
 export { takeRight } from '../array/takeRight.mjs';
 export { takeRightWhile } from '../array/takeRightWhile.mjs';
 export { takeWhile } from '../array/takeWhile.mjs';
@@ -47,64 +45,62 @@ export { zipObject } from '../array/zipObject.mjs';
 export { zipWith } from '../array/zipWith.mjs';
 export { AbortError } from '../error/AbortError.mjs';
 export { TimeoutError } from '../error/TimeoutError.mjs';
-export { before } from '../function/before.mjs';
 export { after } from '../function/after.mjs';
+export { memoize } from '../function/memoize.mjs';
+export { negate } from '../function/negate.mjs';
 export { noop } from '../function/noop.mjs';
 export { once } from '../function/once.mjs';
-export { negate } from '../function/negate.mjs';
-export { memoize } from '../function/memoize.mjs';
-export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
-export { curryRight } from '../function/curryRight.mjs';
+export { unary } from '../function/unary.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';
+export { range } from '../math/range.mjs';
+export { rangeRight } from '../math/rangeRight.mjs';
 export { sum } from '../math/sum.mjs';
 export { sumBy } from '../math/sumBy.mjs';
-export { range } from '../math/range.mjs';
-export { omitBy } from '../object/omitBy.mjs';
-export { pickBy } from '../object/pickBy.mjs';
-export { invert } from '../object/invert.mjs';
 export { clone } from '../object/clone.mjs';
-export { flattenObject } from '../object/flattenObject.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
-export { toMerged } from '../object/toMerged.mjs';
+export { flattenObject } from '../object/flattenObject.mjs';
+export { invert } from '../object/invert.mjs';
 export { isObjectLike } from './predicate/isObjectLike.mjs';
-export { isArrayBuffer } from '../predicate/isArrayBuffer.mjs';
-export { isDate } from '../predicate/isDate.mjs';
+export { omitBy } from '../object/omitBy.mjs';
+export { pickBy } from '../object/pickBy.mjs';
+export { toMerged } from '../object/toMerged.mjs';
+export { isBlob } from '../predicate/isBlob.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
-export { isEqualWith } from '../predicate/isEqualWith.mjs';
-export { isMap } from '../predicate/isMap.mjs';
-export { isNotNil } from '../predicate/isNotNil.mjs';
-export { isNull } from '../predicate/isNull.mjs';
-export { isUndefined } from '../predicate/isUndefined.mjs';
-export { isLength } from '../predicate/isLength.mjs';
+export { eq } from './util/eq.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
+export { isJSONArray } from '../predicate/isJSONArray.mjs';
 export { isJSONObject } from '../predicate/isJSONObject.mjs';
 export { isJSONValue } from '../predicate/isJSONValue.mjs';
-export { isJSONArray } from '../predicate/isJSONArray.mjs';
-export { isSet } from '../predicate/isSet.mjs';
+export { isLength } from '../predicate/isLength.mjs';
+export { isNotNil } from '../predicate/isNotNil.mjs';
+export { isNull } from '../predicate/isNull.mjs';
+export { isUndefined } from '../predicate/isUndefined.mjs';
 export { delay } from '../promise/delay.mjs';
-export { withTimeout } from '../promise/withTimeout.mjs';
 export { timeout } from '../promise/timeout.mjs';
+export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
-export { pascalCase } from '../string/pascalCase.mjs';
 export { constantCase } from '../string/constantCase.mjs';
-export { upperFirst } from '../string/upperFirst.mjs';
-export { lowerFirst } from '../string/lowerFirst.mjs';
 export { deburr } from '../string/deburr.mjs';
 export { escape } from '../string/escape.mjs';
 export { escapeRegExp } from '../string/escapeRegExp.mjs';
+export { lowerFirst } from '../string/lowerFirst.mjs';
+export { pascalCase } from '../string/pascalCase.mjs';
 export { unescape } from '../string/unescape.mjs';
+export { upperFirst } from '../string/upperFirst.mjs';
 export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { drop } from './array/drop.mjs';
+export { dropRightWhile } from './array/dropRightWhile.mjs';
 export { dropWhile } from './array/dropWhile.mjs';
 export { every } from './array/every.mjs';
 export { fill } from './array/fill.mjs';
+export { filter } from './array/filter.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';
 export { findLastIndex } from './array/findLastIndex.mjs';
@@ -115,89 +111,104 @@ export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { join } from './array/join.mjs';
 export { orderBy } from './array/orderBy.mjs';
-export { sortBy } from './array/sortBy.mjs';
 export { size } from './array/size.mjs';
+export { slice } from './array/slice.mjs';
 export { some } from './array/some.mjs';
+export { sortBy } from './array/sortBy.mjs';
+export { take } from './array/take.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
-export { filter } from './array/filter.mjs';
 export { ary } from './function/ary.mjs';
+export { attempt } from './function/attempt.mjs';
+export { before } from './function/before.mjs';
 export { bind } from './function/bind.mjs';
 export { bindKey } from './function/bindKey.mjs';
-export { defer } from './function/defer.mjs';
-export { rest } from './function/rest.mjs';
-export { spread } from './function/spread.mjs';
-export { attempt } from './function/attempt.mjs';
-export { rearg } from './function/rearg.mjs';
 export { curry } from './function/curry.mjs';
+export { curryRight } from './function/curryRight.mjs';
 export { debounce } from './function/debounce.mjs';
-export { throttle } from './function/throttle.mjs';
+export { defer } from './function/defer.mjs';
 export { flip } from './function/flip.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
+export { rearg } from './function/rearg.mjs';
+export { rest } from './function/rest.mjs';
+export { spread } from './function/spread.mjs';
+export { throttle } from './function/throttle.mjs';
+export { ceil } from './math/ceil.mjs';
+export { clamp } from './math/clamp.mjs';
+export { floor } from './math/floor.mjs';
+export { inRange } from './math/inRange.mjs';
+export { max } from './math/max.mjs';
+export { min } from './math/min.mjs';
+export { parseInt } from './math/parseInt.mjs';
+export { random } from './math/random.mjs';
+export { round } from './math/round.mjs';
+export { cloneDeep } from './object/cloneDeep.mjs';
+export { defaults } from './object/defaults.mjs';
+export { fromPairs } from './object/fromPairs.mjs';
 export { get } from './object/get.mjs';
-export { set } from './object/set.mjs';
-export { pick } from './object/pick.mjs';
-export { omit } from './object/omit.mjs';
 export { has } from './object/has.mjs';
-export { property } from './object/property.mjs';
+export { invertBy } from './object/invertBy.mjs';
 export { mapKeys } from './object/mapKeys.mjs';
 export { mapValues } from './object/mapValues.mjs';
 export { merge } from './object/merge.mjs';
 export { mergeWith } from './object/mergeWith.mjs';
-export { fromPairs } from './object/fromPairs.mjs';
+export { omit } from './object/omit.mjs';
+export { pick } from './object/pick.mjs';
+export { property } from './object/property.mjs';
+export { set } from './object/set.mjs';
+export { toDefaulted } from './object/toDefaulted.mjs';
 export { unset } from './object/unset.mjs';
-export { cloneDeep } from './object/cloneDeep.mjs';
-export { isPlainObject } from './predicate/isPlainObject.mjs';
-export { isArray } from './predicate/isArray.mjs';
+export { conforms } from './predicate/conforms.mjs';
+export { conformsTo } from './predicate/conformsTo.mjs';
 export { isArguments } from './predicate/isArguments.mjs';
+export { isArray } from './predicate/isArray.mjs';
+export { isArrayBuffer } from './predicate/isArrayBuffer.mjs';
 export { isArrayLike } from './predicate/isArrayLike.mjs';
-export { isSymbol } from './predicate/isSymbol.mjs';
-export { isObject } from './predicate/isObject.mjs';
+export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
+export { isDate } from './predicate/isDate.mjs';
+export { isEqualWith } from './predicate/isEqualWith.mjs';
 export { isError } from './predicate/isError.mjs';
 export { isFinite } from './predicate/isFinite.mjs';
-export { isTypedArray } from './predicate/isTypedArray.mjs';
+export { isInteger } from './predicate/isInteger.mjs';
+export { isMap } from './predicate/isMap.mjs';
 export { isMatch } from './predicate/isMatch.mjs';
+export { isNaN } from './predicate/isNaN.mjs';
+export { isNil } from './predicate/isNil.mjs';
+export { isNumber } from './predicate/isNumber.mjs';
+export { isObject } from './predicate/isObject.mjs';
+export { isPlainObject } from './predicate/isPlainObject.mjs';
 export { isRegExp } from './predicate/isRegExp.mjs';
+export { isSafeInteger } from './predicate/isSafeInteger.mjs';
+export { isSet } from './predicate/isSet.mjs';
 export { isString } from './predicate/isString.mjs';
-export { matches } from './predicate/matches.mjs';
-export { matchesProperty } from './predicate/matchesProperty.mjs';
+export { isSymbol } from './predicate/isSymbol.mjs';
+export { isTypedArray } from './predicate/isTypedArray.mjs';
 export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
-export { conforms } from './predicate/conforms.mjs';
-export { conformsTo } from './predicate/conformsTo.mjs';
-export { isInteger } from './predicate/isInteger.mjs';
-export { isSafeInteger } from './predicate/isSafeInteger.mjs';
-export { isNumber } from './predicate/isNumber.mjs';
-export { isNaN } from './predicate/isNaN.mjs';
-export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs';
-export { isNil } from './predicate/isNil.mjs';
+export { matches } from './predicate/matches.mjs';
+export { matchesProperty } from './predicate/matchesProperty.mjs';
 export { camelCase } from './string/camelCase.mjs';
+export { endsWith } from './string/endsWith.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
-export { snakeCase } from './string/snakeCase.mjs';
-export { startCase } from './string/startCase.mjs';
 export { lowerCase } from './string/lowerCase.mjs';
-export { upperCase } from './string/upperCase.mjs';
-export { startsWith } from './string/startsWith.mjs';
-export { endsWith } from './string/endsWith.mjs';
 export { pad } from './string/pad.mjs';
-export { padStart } from './string/padStart.mjs';
 export { padEnd } from './string/padEnd.mjs';
+export { padStart } from './string/padStart.mjs';
 export { repeat } from './string/repeat.mjs';
+export { snakeCase } from './string/snakeCase.mjs';
+export { startCase } from './string/startCase.mjs';
+export { startsWith } from './string/startsWith.mjs';
+export { upperCase } from './string/upperCase.mjs';
 export { trim } from './string/trim.mjs';
-export { trimStart } from './string/trimStart.mjs';
 export { trimEnd } from './string/trimEnd.mjs';
-export { clamp } from './math/clamp.mjs';
-export { max } from './math/max.mjs';
-export { min } from './math/min.mjs';
-export { ceil } from './math/ceil.mjs';
-export { floor } from './math/floor.mjs';
-export { round } from './math/round.mjs';
-export { parseInt } from './math/parseInt.mjs';
-export { inRange } from './math/inRange.mjs';
-export { random } from './math/random.mjs';
+export { trimStart } from './string/trimStart.mjs';
+export { constant } from './util/constant.mjs';
+export { defaultTo } from './util/defaultTo.mjs';
+export { times } from './util/times.mjs';
+export { toFinite } from './util/toFinite.mjs';
+export { toInteger } from './util/toInteger.mjs';
+export { toLength } from './util/toLength.mjs';
+export { toNumber } from './util/toNumber.mjs';
 export { toPath } from './util/toPath.mjs';
 export { toString } from './util/toString.mjs';
-export { toNumber } from './util/toNumber.mjs';
-export { toInteger } from './util/toInteger.mjs';
-export { toFinite } from './util/toFinite.mjs';

package/dist/compat/object/defaults.d.mts

@@ -0,0 +1,120 @@
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @param {T} object - The target object.
+ * @returns {T} The object itself.
+ */
+declare function defaults<T extends object>(object: T): NonNullable<T>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S} source - The object that specifies the default values to apply.
+ * @returns {NonNullable<T & S>} The `object` that has been updated with default values from `source`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S extends object>(object: T, source: S): NonNullable<T & S>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2>} The `object` that has been updated with default values from `source1` and `source2`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object>(object: T, source1: S1, source2: S2): NonNullable<T & S1 & S2>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3>} The `object` that has been updated with default values from `source1`, `source2`, and `source3`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object, S3 extends object>(object: T, source1: S1, source2: S2, source3: S3): NonNullable<T & S1 & S2 & S3>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @template S4 - The type of the fourth object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @param {S4} source4 - The fourth object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3 & S4>} The `object` that has been updated with default values from `source1`, `source2`, `source3`, and `source4`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object, S3 extends object, S4 extends object>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable<T & S1 & S2 & S3 & S4>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the objects that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S[]} source - The objects that specifies the default values to apply.
+ * @returns {object} The `object` that has been updated with default values from `sources`, ensuring that all properties are defined and none are left as `undefined`.
+ *
+ * @example
+ * defaults({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * defaults({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * defaults({ a: null }, { a: 1 }); // { a: null }
+ * defaults({ a: undefined }, { a: 1 }); // { a: 1 }
+ */
+declare function defaults<T extends object, S extends object>(object: T, ...sources: S[]): object;
+
+export { defaults };

package/dist/compat/object/defaults.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @param {T} object - The target object.
+ * @returns {T} The object itself.
+ */
+declare function defaults<T extends object>(object: T): NonNullable<T>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S} source - The object that specifies the default values to apply.
+ * @returns {NonNullable<T & S>} The `object` that has been updated with default values from `source`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S extends object>(object: T, source: S): NonNullable<T & S>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2>} The `object` that has been updated with default values from `source1` and `source2`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object>(object: T, source1: S1, source2: S2): NonNullable<T & S1 & S2>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3>} The `object` that has been updated with default values from `source1`, `source2`, and `source3`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object, S3 extends object>(object: T, source1: S1, source2: S2, source3: S3): NonNullable<T & S1 & S2 & S3>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @template S4 - The type of the fourth object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @param {S4} source4 - The fourth object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3 & S4>} The `object` that has been updated with default values from `source1`, `source2`, `source3`, and `source4`, ensuring that all properties are defined and none are left as `undefined`.
+ */
+declare function defaults<T extends object, S1 extends object, S2 extends object, S3 extends object, S4 extends object>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable<T & S1 & S2 & S3 & S4>;
+/**
+ * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`.
+ * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`.
+ *
+ * You can pass in multiple objects to define these default values,
+ * and they will be applied in order from left to right.
+ * Once a property has been assigned a value, any subsequent values for that property will be ignored.
+ *
+ * Note: This function modifies the first argument, `object`. If you want to keep `object` unchanged, consider using `toDefaulted` instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the objects that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S[]} source - The objects that specifies the default values to apply.
+ * @returns {object} The `object` that has been updated with default values from `sources`, ensuring that all properties are defined and none are left as `undefined`.
+ *
+ * @example
+ * defaults({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * defaults({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * defaults({ a: null }, { a: 1 }); // { a: null }
+ * defaults({ a: undefined }, { a: 1 }); // { a: 1 }
+ */
+declare function defaults<T extends object, S extends object>(object: T, ...sources: S[]): object;
+
+export { defaults };

package/dist/compat/object/defaults.mjs

@@ -0,0 +1,21 @@
+import { eq } from '../util/eq.mjs';
+
+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) && eq(value, objectProto[key]))) {
+                object[key] = source[key];
+            }
+        }
+    }
+    return object;
+}
+
+export { defaults };

package/dist/compat/object/invertBy.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Creates a new object that reverses the keys and values of the given object, similar to the invert.
+ *
+ * The `iteratee` function specifies how the values are reversed into keys. If no `iteratee` function is provided, the values are used as keys as-is.
+ *
+ * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function.
+ *
+ * @param {Record<K, V>} object - The object to iterate over.
+ * @param {(value: V) => string} [iteratee] - Optional. A function that generates a key based on each value in the object.
+ * If not provided, the function defaults to using the value as a string.
+ *
+ * @returns {Record<string, K[]>} An object where the keys are generated by the iteratee, and the values
+ * are arrays of property names (keys) from the input object that correspond to those keys.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 1 };
+ * const result = invertBy(obj);
+ * // result => { '1': ['a', 'c'], '2': ['b'] }
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 1 };
+ * const result = invertBy(obj, value => `group${value}`);
+ * // result => { 'group1': ['a', 'c'], 'group2': ['b'] }
+ */
+declare function invertBy<K extends PropertyKey, V>(object: Record<K, V>, iteratee?: (value: V) => string): Record<string, K[]>;
+
+export { invertBy };

package/dist/compat/object/invertBy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a new object that reverses the keys and values of the given object, similar to the invert.
+ *
+ * The `iteratee` function specifies how the values are reversed into keys. If no `iteratee` function is provided, the values are used as keys as-is.
+ *
+ * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function.
+ *
+ * @param {Record<K, V>} object - The object to iterate over.
+ * @param {(value: V) => string} [iteratee] - Optional. A function that generates a key based on each value in the object.
+ * If not provided, the function defaults to using the value as a string.
+ *
+ * @returns {Record<string, K[]>} An object where the keys are generated by the iteratee, and the values
+ * are arrays of property names (keys) from the input object that correspond to those keys.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 1 };
+ * const result = invertBy(obj);
+ * // result => { '1': ['a', 'c'], '2': ['b'] }
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 1 };
+ * const result = invertBy(obj, value => `group${value}`);
+ * // result => { 'group1': ['a', 'c'], 'group2': ['b'] }
+ */
+declare function invertBy<K extends PropertyKey, V>(object: Record<K, V>, iteratee?: (value: V) => string): Record<string, K[]>;
+
+export { invertBy };

package/dist/compat/object/invertBy.mjs

@@ -0,0 +1,27 @@
+import { isNil } from '../../predicate/isNil.mjs';
+import { identity } from '../_internal/identity.mjs';
+
+function invertBy(object, iteratee) {
+    const result = {};
+    if (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;
+}
+
+export { invertBy };

package/dist/compat/object/omit.d.mts

@@ -26,7 +26,7 @@ declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T,
  *
  * @template T - The type of object.
  * @param {T} obj - The object to omit keys from.
- * @param {...(PropertyKey | PropertyKey[] | PropertyKey[][]} keys - A variable number of keys to be omitted from the object.
+ * @param {...(PropertyKey | PropertyKey[] | PropertyKey[][])} keys - A variable number of keys to be omitted from the object.
  * @returns {Partial<T>} A new object with the specified keys omitted.
  */
 declare function omit<T extends {}>(obj: T | null | undefined, ...keys: Array<PropertyKey | readonly PropertyKey[] | ReadonlyArray<readonly PropertyKey[]>>): Partial<T>;

package/dist/compat/object/omit.d.ts

@@ -26,7 +26,7 @@ declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T,
  *
  * @template T - The type of object.
  * @param {T} obj - The object to omit keys from.
- * @param {...(PropertyKey | PropertyKey[] | PropertyKey[][]} keys - A variable number of keys to be omitted from the object.
+ * @param {...(PropertyKey | PropertyKey[] | PropertyKey[][])} keys - A variable number of keys to be omitted from the object.
  * @returns {Partial<T>} A new object with the specified keys omitted.
  */
 declare function omit<T extends {}>(obj: T | null | undefined, ...keys: Array<PropertyKey | readonly PropertyKey[] | ReadonlyArray<readonly PropertyKey[]>>): Partial<T>;

package/dist/compat/object/pick.d.mts

@@ -25,7 +25,7 @@ declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T,
  * @template T - The type of object.
  * @param {T | null | undefined} obj - The object to pick keys from.
  * @param {...any} keys
- * @param {PropertyKey | PropertyKey[] | ProperyKey[][]}} keys - An array of keys to be picked from the object. received keysgoes through a flattening process before being used.
+ * @param {PropertyKey | PropertyKey[] | PropertyKey[][]}} keys - An array of keys to be picked from the object. received keys goes through a flattening process before being used.
  * @returns {Partial<T, K>} A new object with the specified keys picked.
  *
  * @example