es-toolkit 1.37.2 → 1.38.0-dev.1285

package/dist/compat/index.mjs

@@ -30,6 +30,7 @@ export { initial } from './array/initial.mjs';
 export { intersection } from './array/intersection.mjs';
 export { intersectionBy } from './array/intersectionBy.mjs';
 export { intersectionWith } from './array/intersectionWith.mjs';
+export { invokeMap } from './array/invokeMap.mjs';
 export { join } from './array/join.mjs';
 export { keyBy } from './array/keyBy.mjs';
 export { last } from './array/last.mjs';
@@ -60,6 +61,7 @@ export { sortedIndexBy } from './array/sortedIndexBy.mjs';
 export { sortedIndexOf } from './array/sortedIndexOf.mjs';
 export { sortedLastIndex } from './array/sortedLastIndex.mjs';
 export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs';
+export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -95,7 +97,7 @@ export { delay } from './function/delay.mjs';
 export { flip } from './function/flip.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
-export { memoize } from '../function/memoize.mjs';
+export { memoize } from './function/memoize.mjs';
 export { negate } from './function/negate.mjs';
 export { nthArg } from './function/nthArg.mjs';
 export { once } from '../function/once.mjs';
@@ -133,9 +135,10 @@ export { assignIn, assignIn as extend } from './object/assignIn.mjs';
 export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs';
 export { assignWith } from './object/assignWith.mjs';
 export { at } from './object/at.mjs';
-export { clone } from '../object/clone.mjs';
+export { clone } from './object/clone.mjs';
 export { cloneDeep } from './object/cloneDeep.mjs';
 export { cloneDeepWith } from './object/cloneDeepWith.mjs';
+export { cloneWith } from './object/cloneWith.mjs';
 export { create } from './object/create.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
@@ -155,6 +158,7 @@ export { invertBy } from './object/invertBy.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isLength } from '../predicate/isLength.mjs';
+export { isNative } from './predicate/isNative.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
 export { keys } from './object/keys.mjs';
@@ -172,6 +176,7 @@ export { property } from './object/property.mjs';
 export { propertyOf } from './object/propertyOf.mjs';
 export { result } from './object/result.mjs';
 export { set } from './object/set.mjs';
+export { setWith } from './object/setWith.mjs';
 export { toDefaulted } from './object/toDefaulted.mjs';
 export { toPairs } from './object/toPairs.mjs';
 export { toPairsIn } from './object/toPairsIn.mjs';
@@ -181,6 +186,7 @@ export { update } from './object/update.mjs';
 export { updateWith } from './object/updateWith.mjs';
 export { values } from './object/values.mjs';
 export { valuesIn } from './object/valuesIn.mjs';
+export { bindAll } from './util/bindAll.mjs';
 export { capitalize } from '../string/capitalize.mjs';
 export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';

package/dist/compat/math/max.d.mts

@@ -1,8 +1,9 @@
 /**
  * Finds the element in an array that has the maximum value.
  *
+ * @template T - The type of elements in the array.
  * @param {[T, ...T[]]} items - The array of elements to search.
- * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty.
+ * @returns {T} - The element with the maximum value.
  * @example
  * // Returns 9
  * max([3, 1, 4, 1, 5, 9]);
@@ -15,16 +16,17 @@ declare function max<T>(items: readonly [T, ...T[]]): T;
 /**
  * Finds the element in an array that has the maximum value.
  * Returns undefined when no arguments are provided.
- * @returns {undefined}
+ *
+ * @returns {undefined} - Returns `undefined` when the function is called with no arguments.
  */
 declare function max(): undefined;
 /**
  * Finds the element in an array that has the maximum value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} [items] - The array of elements to search. Defaults to an empty array.
- * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty.
+ * @param {ArrayLike<T> | null | undefined} [items] - The array of elements to search.
+ * @returns {T | undefined} - The element with the maximum value, or `undefined` if the array is empty, `null`, or `undefined`.
  */
-declare function max<T>(items?: readonly T[]): T | undefined;
+declare function max<T>(items?: ArrayLike<T> | null | undefined): T | undefined;
 
 export { max };

package/dist/compat/math/max.d.ts

@@ -1,8 +1,9 @@
 /**
  * Finds the element in an array that has the maximum value.
  *
+ * @template T - The type of elements in the array.
  * @param {[T, ...T[]]} items - The array of elements to search.
- * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty.
+ * @returns {T} - The element with the maximum value.
  * @example
  * // Returns 9
  * max([3, 1, 4, 1, 5, 9]);
@@ -15,16 +16,17 @@ declare function max<T>(items: readonly [T, ...T[]]): T;
 /**
  * Finds the element in an array that has the maximum value.
  * Returns undefined when no arguments are provided.
- * @returns {undefined}
+ *
+ * @returns {undefined} - Returns `undefined` when the function is called with no arguments.
  */
 declare function max(): undefined;
 /**
  * Finds the element in an array that has the maximum value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} [items] - The array of elements to search. Defaults to an empty array.
- * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty.
+ * @param {ArrayLike<T> | null | undefined} [items] - The array of elements to search.
+ * @returns {T | undefined} - The element with the maximum value, or `undefined` if the array is empty, `null`, or `undefined`.
  */
-declare function max<T>(items?: readonly T[]): T | undefined;
+declare function max<T>(items?: ArrayLike<T> | null | undefined): T | undefined;
 
 export { max };

package/dist/compat/math/max.mjs

@@ -1,14 +1,18 @@
-function max(items = []) {
-    let maxElement = items[0];
-    let max = undefined;
+function max(items) {
+    if (!items || items.length === 0) {
+        return undefined;
+    }
+    let maxResult = undefined;
     for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (max == null || element > max) {
-            max = element;
-            maxElement = element;
+        const current = items[i];
+        if (current == null || Number.isNaN(current) || typeof current === 'symbol') {
+            continue;
+        }
+        if (maxResult === undefined || current > maxResult) {
+            maxResult = current;
         }
     }
-    return maxElement;
+    return maxResult;
 }
 
 export { max };

package/dist/compat/math/min.d.mts

@@ -3,7 +3,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {[T, ...T[]]} items - The array of elements to search.
- * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty.
+ * @returns {T} - The element with the minimum value.
  * @example
  * // Returns 1
  * min([3, 1, 4, 1, 5, 9]);
@@ -16,16 +16,17 @@ declare function min<T>(items: readonly [T, ...T[]]): T;
 /**
  * Finds the element in an array that has the minimum value.
  * Returns undefined when no arguments are provided.
- * @returns {undefined}
+ *
+ * @returns {undefined} - Returns `undefined` when the function is called with no arguments.
  */
 declare function min(): undefined;
 /**
  * Finds the element in an array that has the minimum value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} [items] - The array of elements to search. Defaults to an empty array.
- * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty.
+ * @param {ArrayLike<T> | null | undefined} [items] - The array of elements to search.
+ * @returns {T | undefined} - The element with the minimum value, or `undefined` if the array is empty, `null`, or `undefined`.
  */
-declare function min<T>(items?: readonly T[]): T | undefined;
+declare function min<T>(items?: ArrayLike<T> | null | undefined): T | undefined;
 
 export { min };

package/dist/compat/math/min.d.ts

@@ -3,7 +3,7 @@
  *
  * @template T - The type of elements in the array.
  * @param {[T, ...T[]]} items - The array of elements to search.
- * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty.
+ * @returns {T} - The element with the minimum value.
  * @example
  * // Returns 1
  * min([3, 1, 4, 1, 5, 9]);
@@ -16,16 +16,17 @@ declare function min<T>(items: readonly [T, ...T[]]): T;
 /**
  * Finds the element in an array that has the minimum value.
  * Returns undefined when no arguments are provided.
- * @returns {undefined}
+ *
+ * @returns {undefined} - Returns `undefined` when the function is called with no arguments.
  */
 declare function min(): undefined;
 /**
  * Finds the element in an array that has the minimum value.
  *
  * @template T - The type of elements in the array.
- * @param {T[]} [items] - The array of elements to search. Defaults to an empty array.
- * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty.
+ * @param {ArrayLike<T> | null | undefined} [items] - The array of elements to search.
+ * @returns {T | undefined} - The element with the minimum value, or `undefined` if the array is empty, `null`, or `undefined`.
  */
-declare function min<T>(items?: readonly T[]): T | undefined;
+declare function min<T>(items?: ArrayLike<T> | null | undefined): T | undefined;
 
 export { min };

package/dist/compat/math/min.mjs

@@ -1,14 +1,18 @@
-function min(items = []) {
-    let minElement = items[0];
-    let min = undefined;
+function min(items) {
+    if (!items || items.length === 0) {
+        return undefined;
+    }
+    let minResult = undefined;
     for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (min == null || element < min) {
-            min = element;
-            minElement = element;
+        const current = items[i];
+        if (current == null || Number.isNaN(current) || typeof current === 'symbol') {
+            continue;
+        }
+        if (minResult === undefined || current < minResult) {
+            minResult = current;
         }
     }
-    return minElement;
+    return minResult;
 }
 
 export { min };

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

@@ -0,0 +1,31 @@
+/**
+ * Creates a shallow clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A shallow clone of the given object.
+ *
+ * @example
+ * // Clone a primitive objs
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ */
+declare function clone<T>(obj: T): T;
+
+export { clone };

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

@@ -0,0 +1,31 @@
+/**
+ * Creates a shallow clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A shallow clone of the given object.
+ *
+ * @example
+ * // Clone a primitive objs
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ */
+declare function clone<T>(obj: T): T;
+
+export { clone };

package/dist/compat/object/clone.mjs

@@ -0,0 +1,160 @@
+import { isPrimitive } from '../../predicate/isPrimitive.mjs';
+import { getTag } from '../_internal/getTag.mjs';
+import { arrayBufferTag, dataViewTag, booleanTag, numberTag, stringTag, dateTag, regexpTag, symbolTag, mapTag, setTag, argumentsTag, uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, objectTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, float64ArrayTag, float32ArrayTag, arrayTag } from '../_internal/tags.mjs';
+import { isArray } from '../predicate/isArray.mjs';
+import { isTypedArray } from '../predicate/isTypedArray.mjs';
+
+function clone(obj) {
+    if (isPrimitive(obj)) {
+        return obj;
+    }
+    const tag = getTag(obj);
+    if (!isCloneableObject(obj)) {
+        return {};
+    }
+    if (isArray(obj)) {
+        const result = Array.from(obj);
+        if (obj.length > 0 && typeof obj[0] === 'string' && Object.hasOwn(obj, 'index')) {
+            result.index = obj.index;
+            result.input = obj.input;
+        }
+        return result;
+    }
+    if (isTypedArray(obj)) {
+        const typedArray = obj;
+        const Ctor = typedArray.constructor;
+        return new Ctor(typedArray.buffer, typedArray.byteOffset, typedArray.length);
+    }
+    if (tag === arrayBufferTag) {
+        return new ArrayBuffer(obj.byteLength);
+    }
+    if (tag === dataViewTag) {
+        const dataView = obj;
+        const buffer = dataView.buffer;
+        const byteOffset = dataView.byteOffset;
+        const byteLength = dataView.byteLength;
+        const clonedBuffer = new ArrayBuffer(byteLength);
+        const srcView = new Uint8Array(buffer, byteOffset, byteLength);
+        const destView = new Uint8Array(clonedBuffer);
+        destView.set(srcView);
+        return new DataView(clonedBuffer);
+    }
+    if (tag === booleanTag || tag === numberTag || tag === stringTag) {
+        const Ctor = obj.constructor;
+        const clone = new Ctor(obj.valueOf());
+        if (tag === stringTag) {
+            cloneStringObjectProperties(clone, obj);
+        }
+        else {
+            copyOwnProperties(clone, obj);
+        }
+        return clone;
+    }
+    if (tag === dateTag) {
+        return new Date(Number(obj));
+    }
+    if (tag === regexpTag) {
+        const regExp = obj;
+        const clone = new RegExp(regExp.source, regExp.flags);
+        clone.lastIndex = regExp.lastIndex;
+        return clone;
+    }
+    if (tag === symbolTag) {
+        return Object(Symbol.prototype.valueOf.call(obj));
+    }
+    if (tag === mapTag) {
+        const map = obj;
+        const result = new Map();
+        map.forEach((obj, key) => {
+            result.set(key, obj);
+        });
+        return result;
+    }
+    if (tag === setTag) {
+        const set = obj;
+        const result = new Set();
+        set.forEach(obj => {
+            result.add(obj);
+        });
+        return result;
+    }
+    if (tag === argumentsTag) {
+        const args = obj;
+        const result = {};
+        copyOwnProperties(result, args);
+        result.length = args.length;
+        result[Symbol.iterator] = args[Symbol.iterator];
+        return result;
+    }
+    const result = {};
+    copyPrototype(result, obj);
+    copyOwnProperties(result, obj);
+    copySymbolProperties(result, obj);
+    return result;
+}
+function isCloneableObject(object) {
+    switch (getTag(object)) {
+        case argumentsTag:
+        case arrayTag:
+        case arrayBufferTag:
+        case dataViewTag:
+        case booleanTag:
+        case dateTag:
+        case float32ArrayTag:
+        case float64ArrayTag:
+        case int8ArrayTag:
+        case int16ArrayTag:
+        case int32ArrayTag:
+        case mapTag:
+        case numberTag:
+        case objectTag:
+        case regexpTag:
+        case setTag:
+        case stringTag:
+        case symbolTag:
+        case uint8ArrayTag:
+        case uint8ClampedArrayTag:
+        case uint16ArrayTag:
+        case uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+function copyOwnProperties(target, source) {
+    for (const key in source) {
+        if (Object.hasOwn(source, key)) {
+            target[key] = source[key];
+        }
+    }
+}
+function copySymbolProperties(target, source) {
+    const symbols = Object.getOwnPropertySymbols(source);
+    for (let i = 0; i < symbols.length; i++) {
+        const symbol = symbols[i];
+        if (Object.prototype.propertyIsEnumerable.call(source, symbol)) {
+            target[symbol] = source[symbol];
+        }
+    }
+}
+function cloneStringObjectProperties(target, source) {
+    const stringLength = source.valueOf().length;
+    for (const key in source) {
+        if (Object.hasOwn(source, key) && (Number.isNaN(Number(key)) || Number(key) >= stringLength)) {
+            target[key] = source[key];
+        }
+    }
+}
+function copyPrototype(target, source) {
+    const proto = Object.getPrototypeOf(source);
+    if (proto !== null) {
+        const Ctor = source.constructor;
+        if (typeof Ctor === 'function') {
+            Object.setPrototypeOf(target, proto);
+        }
+    }
+}
+
+export { clone };

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

@@ -0,0 +1,48 @@
+/**
+ * Creates a shallow clone of the given object with customization.
+ * This method is like `_.clone` except that it accepts a customizer which
+ * is invoked to produce the cloned value. If customizer returns undefined,
+ * cloning is handled by the method instead.
+ *
+ * If no customizer is provided, it behaves like `clone`.
+ *
+ * @template T - The type of the object.
+ * @param {T} value - The value to clone.
+ * @param {Function} [customizer] - The function to customize cloning.
+ * @returns {T} - A shallow clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = cloneWith(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = cloneWith(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = cloneWith(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an object with a customizer
+ * const obj = { a: 1, b: 2 };
+ * const clonedObj = cloneWith(obj, (value) => {
+ *   if (typeof value === 'number') {
+ *     return value * 2; // Double the number
+ *   }
+ *   // Returning undefined uses the default cloning
+ * });
+ * console.log(clonedObj); // { a: 2, b: 4 }
+ */
+declare function cloneWith<T>(value: T, customizer?: (value: any) => any): T;
+
+export { cloneWith };

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

@@ -0,0 +1,48 @@
+/**
+ * Creates a shallow clone of the given object with customization.
+ * This method is like `_.clone` except that it accepts a customizer which
+ * is invoked to produce the cloned value. If customizer returns undefined,
+ * cloning is handled by the method instead.
+ *
+ * If no customizer is provided, it behaves like `clone`.
+ *
+ * @template T - The type of the object.
+ * @param {T} value - The value to clone.
+ * @param {Function} [customizer] - The function to customize cloning.
+ * @returns {T} - A shallow clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = cloneWith(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = cloneWith(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = cloneWith(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an object with a customizer
+ * const obj = { a: 1, b: 2 };
+ * const clonedObj = cloneWith(obj, (value) => {
+ *   if (typeof value === 'number') {
+ *     return value * 2; // Double the number
+ *   }
+ *   // Returning undefined uses the default cloning
+ * });
+ * console.log(clonedObj); // { a: 2, b: 4 }
+ */
+declare function cloneWith<T>(value: T, customizer?: (value: any) => any): T;
+
+export { cloneWith };

package/dist/compat/object/cloneWith.mjs

@@ -0,0 +1,14 @@
+import { clone } from './clone.mjs';
+
+function cloneWith(value, customizer) {
+    if (!customizer) {
+        return clone(value);
+    }
+    const result = customizer(value);
+    if (result !== undefined) {
+        return result;
+    }
+    return clone(value);
+}
+
+export { cloneWith };

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

@@ -17,7 +17,7 @@ declare function findKey<T extends Record<any, any>>(obj: T | null | undefined,
  *
  * @template T - The type of the object.
  * @param {T | null | undefined} obj - The object to inspect.
- * @param {Partail<T[keyof T]>} objectToFind - The object to match.
+ * @param {Partial<T[keyof T]>} objectToFind - The object to match.
  * @returns {keyof T | undefined} Returns the key of the matched element, else `undefined`.
  *
  * @example

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

@@ -17,7 +17,7 @@ declare function findKey<T extends Record<any, any>>(obj: T | null | undefined,
  *
  * @template T - The type of the object.
  * @param {T | null | undefined} obj - The object to inspect.
- * @param {Partail<T[keyof T]>} objectToFind - The object to match.
+ * @param {Partial<T[keyof T]>} objectToFind - The object to match.
  * @returns {keyof T | undefined} Returns the key of the matched element, else `undefined`.
  *
  * @example

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

@@ -0,0 +1,25 @@
+/**
+ * Sets the value at the specified path of the given object using a customizer function.
+ * If any part of the path does not exist, it will be created based on the customizer's result.
+ *
+ * The customizer is invoked to produce the objects of the path. If the customizer returns
+ * a value, that value is used for the current path segment. If the customizer returns
+ * `undefined`, the method will create an appropriate object based on the path - an array
+ * if the next path segment is a valid array index, or an object otherwise.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to modify.
+ * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to set.
+ * @param {unknown} value - The value to set.
+ * @param {(value: unknown) => unknown} [customizer] - The function to customize assigned values.
+ * @returns {T} - The modified object.
+ *
+ * @example
+ * // Set a value with a customizer that creates arrays for numeric path segments
+ * const object = {};
+ * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []);
+ * // => { '0': ['a'] }
+ */
+declare function setWith<T extends object | null | undefined>(obj: T, path: PropertyKey | readonly PropertyKey[], value: unknown, customizer?: (value: unknown) => unknown): T;
+
+export { setWith };

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

@@ -0,0 +1,25 @@
+/**
+ * Sets the value at the specified path of the given object using a customizer function.
+ * If any part of the path does not exist, it will be created based on the customizer's result.
+ *
+ * The customizer is invoked to produce the objects of the path. If the customizer returns
+ * a value, that value is used for the current path segment. If the customizer returns
+ * `undefined`, the method will create an appropriate object based on the path - an array
+ * if the next path segment is a valid array index, or an object otherwise.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to modify.
+ * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to set.
+ * @param {unknown} value - The value to set.
+ * @param {(value: unknown) => unknown} [customizer] - The function to customize assigned values.
+ * @returns {T} - The modified object.
+ *
+ * @example
+ * // Set a value with a customizer that creates arrays for numeric path segments
+ * const object = {};
+ * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []);
+ * // => { '0': ['a'] }
+ */
+declare function setWith<T extends object | null | undefined>(obj: T, path: PropertyKey | readonly PropertyKey[], value: unknown, customizer?: (value: unknown) => unknown): T;
+
+export { setWith };

package/dist/compat/object/setWith.mjs

@@ -0,0 +1,14 @@
+import { updateWith } from './updateWith.mjs';
+
+function setWith(obj, path, value, customizer) {
+    let customizerFn;
+    if (typeof customizer === 'function') {
+        customizerFn = customizer;
+    }
+    else {
+        customizerFn = () => undefined;
+    }
+    return updateWith(obj, path, () => value, customizerFn);
+}
+
+export { setWith };