es-toolkit 1.45.1 → 1.46.0-dev.1786

package/dist/compat/predicate/isEmpty.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const isArguments = require('./isArguments.js');
 const isArrayLike = require('./isArrayLike.js');
 const isTypedArray = require('./isTypedArray.js');
+const isBuffer = require('../../predicate/isBuffer.js');
 const isPrototype = require('../_internal/isPrototype.js');
 
 function isEmpty(value) {
@@ -14,7 +15,7 @@ function isEmpty(value) {
     if (isArrayLike.isArrayLike(value)) {
         if (typeof value.splice !== 'function' &&
             typeof value !== 'string' &&
-            (typeof Buffer === 'undefined' || !Buffer.isBuffer(value)) &&
+            !isBuffer.isBuffer(value) &&
             !isTypedArray.isTypedArray(value) &&
             !isArguments.isArguments(value)) {
             return false;

package/dist/compat/predicate/isEmpty.mjs

@@ -1,6 +1,7 @@
 import { isArguments } from './isArguments.mjs';
 import { isArrayLike } from './isArrayLike.mjs';
 import { isTypedArray } from './isTypedArray.mjs';
+import { isBuffer } from '../../predicate/isBuffer.mjs';
 import { isPrototype } from '../_internal/isPrototype.mjs';
 
 function isEmpty(value) {
@@ -10,7 +11,7 @@ function isEmpty(value) {
     if (isArrayLike(value)) {
         if (typeof value.splice !== 'function' &&
             typeof value !== 'string' &&
-            (typeof Buffer === 'undefined' || !Buffer.isBuffer(value)) &&
+            !isBuffer(value) &&
             !isTypedArray(value) &&
             !isArguments(value)) {
             return false;

package/dist/compat/util/over.d.mts

@@ -18,7 +18,7 @@
  *
  * const func = over([{ a: 1 }, { b: 2 }]);
  * func({ a: 1, b: 2 });
- * // => [true, false]
+ * // => [true, true]
  *
  * const func = over([['a', 1], ['b', 2]]);
  * func({ a: 1, b: 2 });

package/dist/compat/util/over.d.ts

@@ -18,7 +18,7 @@
  *
  * const func = over([{ a: 1 }, { b: 2 }]);
  * func({ a: 1, b: 2 });
- * // => [true, false]
+ * // => [true, true]
  *
  * const func = over([['a', 1], ['b', 2]]);
  * func({ a: 1, b: 2 });

package/dist/error/AbortError.d.mts

@@ -1,8 +1,8 @@
 /**
  * An error class representing an aborted operation.
- * @augments Error
+ * @augments DOMException
  */
-declare class AbortError extends Error {
+declare class AbortError extends DOMException {
     constructor(message?: string);
 }
 

package/dist/error/AbortError.d.ts

@@ -1,8 +1,8 @@
 /**
  * An error class representing an aborted operation.
- * @augments Error
+ * @augments DOMException
  */
-declare class AbortError extends Error {
+declare class AbortError extends DOMException {
     constructor(message?: string);
 }
 

package/dist/error/AbortError.js

@@ -2,10 +2,9 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-class AbortError extends Error {
+class AbortError extends DOMException {
     constructor(message = 'The operation was aborted') {
         super(message);
-        this.name = 'AbortError';
     }
 }
 

package/dist/error/AbortError.mjs

@@ -1,7 +1,6 @@
-class AbortError extends Error {
+class AbortError extends DOMException {
     constructor(message = 'The operation was aborted') {
         super(message);
-        this.name = 'AbortError';
     }
 }
 

package/dist/error/TimeoutError.d.mts

@@ -1,8 +1,8 @@
 /**
- * An error class representing an timeout operation.
- * @augments Error
+ * An error class representing a timeout operation.
+ * @augments DOMException
  */
-declare class TimeoutError extends Error {
+declare class TimeoutError extends DOMException {
     constructor(message?: string);
 }
 

package/dist/error/TimeoutError.d.ts

@@ -1,8 +1,8 @@
 /**
- * An error class representing an timeout operation.
- * @augments Error
+ * An error class representing a timeout operation.
+ * @augments DOMException
  */
-declare class TimeoutError extends Error {
+declare class TimeoutError extends DOMException {
     constructor(message?: string);
 }
 

package/dist/error/TimeoutError.js

@@ -2,10 +2,9 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-class TimeoutError extends Error {
+class TimeoutError extends DOMException {
     constructor(message = 'The operation was timed out') {
         super(message);
-        this.name = 'TimeoutError';
     }
 }
 

package/dist/error/TimeoutError.mjs

@@ -1,7 +1,6 @@
-class TimeoutError extends Error {
+class TimeoutError extends DOMException {
     constructor(message = 'The operation was timed out') {
         super(message);
-        this.name = 'TimeoutError';
     }
 }
 

package/dist/function/memoize.d.mts

@@ -68,7 +68,7 @@
  * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
  * console.log(memoizedSumWithCustomCache([1, 2])); // 3
  * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
- * console.log(memoizedAddWithCustomCache.cache.size); // 1
+ * console.log(memoizedSumWithCustomCache.cache.size); // 1
  */
 declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
     cache?: MemoizeCache<any, ReturnType<F>>;

package/dist/function/memoize.d.ts

@@ -68,7 +68,7 @@
  * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
  * console.log(memoizedSumWithCustomCache([1, 2])); // 3
  * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
- * console.log(memoizedAddWithCustomCache.cache.size); // 1
+ * console.log(memoizedSumWithCustomCache.cache.size); // 1
  */
 declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
     cache?: MemoizeCache<any, ReturnType<F>>;

package/dist/function/partial.d.mts

@@ -58,6 +58,27 @@ declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1):
  * console.log(greetWithHello('Hello')); // => 'Hello, John!'
  */
 declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const addThree = partial(add, 1, 2);
+ * console.log(addThree()); // => 3
+ */
+declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -170,6 +191,29 @@ declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) =>
  * console.log(greetWithPlaceholder('John')); // => 'Hello, John!'
  */
 declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template T3 The type of the third argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @param {T3} arg3 The third argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const sum = (a: number, b: number, c: number) => a + b + c;
+ * const sumAll = partial(sum, 1, 2, 3);
+ * console.log(sumAll()); // => 6
+ */
+declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -414,6 +458,31 @@ declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3,
  * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function.
  */
 declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template T3 The type of the third argument.
+ * @template T4 The type of the fourth argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @param {T3} arg3 The third argument to apply.
+ * @param {T4} arg4 The fourth argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d;
+ * const sumAll = partial(sumFour, 1, 2, 3, 4);
+ * console.log(sumAll()); // => 10
+ */
+declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *

package/dist/function/partial.d.ts

@@ -58,6 +58,27 @@ declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1):
  * console.log(greetWithHello('Hello')); // => 'Hello, John!'
  */
 declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const add = (x: number, y: number) => x + y;
+ * const addThree = partial(add, 1, 2);
+ * console.log(addThree()); // => 3
+ */
+declare function partial<T1, T2, R>(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -170,6 +191,29 @@ declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) =>
  * console.log(greetWithPlaceholder('John')); // => 'Hello, John!'
  */
 declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template T3 The type of the third argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @param {T3} arg3 The third argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const sum = (a: number, b: number, c: number) => a + b + c;
+ * const sumAll = partial(sum, 1, 2, 3);
+ * console.log(sumAll()); // => 6
+ */
+declare function partial<T1, T2, T3, R>(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *
@@ -414,6 +458,31 @@ declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3,
  * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function.
  */
 declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R;
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of partially applied functions.
+ *
+ * @template T1 The type of the first argument.
+ * @template T2 The type of the second argument.
+ * @template T3 The type of the third argument.
+ * @template T4 The type of the fourth argument.
+ * @template R The return type of the function.
+ * @param {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply.
+ * @param {T1} arg1 The first argument to apply.
+ * @param {T2} arg2 The second argument to apply.
+ * @param {T3} arg3 The third argument to apply.
+ * @param {T4} arg4 The fourth argument to apply.
+ * @returns {function(): R} A new function that takes no arguments and returns the result of the original function.
+ *
+ * @example
+ * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d;
+ * const sumAll = partial(sumFour, 1, 2, 3, 4);
+ * console.log(sumAll()); // => 10
+ */
+declare function partial<T1, T2, T3, T4, R>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R;
 /**
  * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
  *

package/dist/map/index.d.mts

@@ -3,6 +3,7 @@ export { filter } from './filter.mjs';
 export { findKey } from './findKey.mjs';
 export { findValue } from './findValue.mjs';
 export { hasValue } from './hasValue.mjs';
+export { keyBy } from './keyBy.mjs';
 export { mapKeys } from './mapKeys.mjs';
 export { mapValues } from './mapValues.mjs';
 export { reduce } from './reduce.mjs';

package/dist/map/index.d.ts

@@ -3,6 +3,7 @@ export { filter } from './filter.js';
 export { findKey } from './findKey.js';
 export { findValue } from './findValue.js';
 export { hasValue } from './hasValue.js';
+export { keyBy } from './keyBy.js';
 export { mapKeys } from './mapKeys.js';
 export { mapValues } from './mapValues.js';
 export { reduce } from './reduce.js';

package/dist/map/index.js

@@ -7,6 +7,7 @@ const filter = require('./filter.js');
 const findKey = require('./findKey.js');
 const findValue = require('./findValue.js');
 const hasValue = require('./hasValue.js');
+const keyBy = require('./keyBy.js');
 const mapKeys = require('./mapKeys.js');
 const mapValues = require('./mapValues.js');
 const reduce = require('./reduce.js');
@@ -19,6 +20,7 @@ exports.filter = filter.filter;
 exports.findKey = findKey.findKey;
 exports.findValue = findValue.findValue;
 exports.hasValue = hasValue.hasValue;
+exports.keyBy = keyBy.keyBy;
 exports.mapKeys = mapKeys.mapKeys;
 exports.mapValues = mapValues.mapValues;
 exports.reduce = reduce.reduce;

package/dist/map/index.mjs

@@ -3,6 +3,7 @@ export { filter } from './filter.mjs';
 export { findKey } from './findKey.mjs';
 export { findValue } from './findValue.mjs';
 export { hasValue } from './hasValue.mjs';
+export { keyBy } from './keyBy.mjs';
 export { mapKeys } from './mapKeys.mjs';
 export { mapValues } from './mapValues.mjs';
 export { reduce } from './reduce.mjs';

package/dist/map/keyBy.d.mts

@@ -0,0 +1,31 @@
+/**
+ * Maps each entry of a Map based on a provided key-generating function.
+ *
+ * This function takes a Map and a function that generates a key from each value-key pair.
+ * It returns a new Map where the keys are generated by the key function and the values are
+ * the corresponding values from the original map. If multiple entries produce the same key,
+ * the last value encountered will be used.
+ *
+ * @template K - The type of keys in the original Map.
+ * @template V - The type of values in the original Map.
+ * @template K2 - The type of keys to produce in the returned Map.
+ * @param {Map<K, V>} map - The map of entries to be mapped.
+ * @param {(value: V, key: K, object: Map<K, V>) => K2} getKeyFromEntry - A function that generates a key from a value-key pair.
+ * @returns {Map<K2, V>} A Map where the generated keys are mapped to each entry's value.
+ *
+ * @example
+ * const map = new Map([
+ *   ['x', { type: 'fruit', name: 'apple' }],
+ *   ['y', { type: 'fruit', name: 'banana' }],
+ *   ['z', { type: 'vegetable', name: 'carrot' }]
+ * ]);
+ * const result = keyBy(map, item => item.type);
+ * // result will be:
+ * // Map(2) {
+ * //   'fruit' => { type: 'fruit', name: 'banana' },
+ * //   'vegetable' => { type: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function keyBy<K, V, K2>(map: Map<K, V>, getKeyFromEntry: (value: V, key: K, object: Map<K, V>) => K2): Map<K2, V>;
+
+export { keyBy };

package/dist/map/keyBy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Maps each entry of a Map based on a provided key-generating function.
+ *
+ * This function takes a Map and a function that generates a key from each value-key pair.
+ * It returns a new Map where the keys are generated by the key function and the values are
+ * the corresponding values from the original map. If multiple entries produce the same key,
+ * the last value encountered will be used.
+ *
+ * @template K - The type of keys in the original Map.
+ * @template V - The type of values in the original Map.
+ * @template K2 - The type of keys to produce in the returned Map.
+ * @param {Map<K, V>} map - The map of entries to be mapped.
+ * @param {(value: V, key: K, object: Map<K, V>) => K2} getKeyFromEntry - A function that generates a key from a value-key pair.
+ * @returns {Map<K2, V>} A Map where the generated keys are mapped to each entry's value.
+ *
+ * @example
+ * const map = new Map([
+ *   ['x', { type: 'fruit', name: 'apple' }],
+ *   ['y', { type: 'fruit', name: 'banana' }],
+ *   ['z', { type: 'vegetable', name: 'carrot' }]
+ * ]);
+ * const result = keyBy(map, item => item.type);
+ * // result will be:
+ * // Map(2) {
+ * //   'fruit' => { type: 'fruit', name: 'banana' },
+ * //   'vegetable' => { type: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function keyBy<K, V, K2>(map: Map<K, V>, getKeyFromEntry: (value: V, key: K, object: Map<K, V>) => K2): Map<K2, V>;
+
+export { keyBy };

package/dist/map/keyBy.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function keyBy(map, getKeyFromEntry) {
+    const result = new Map();
+    for (const [key, value] of map) {
+        const newKey = getKeyFromEntry(value, key, map);
+        result.set(newKey, value);
+    }
+    return result;
+}
+
+exports.keyBy = keyBy;

package/dist/map/keyBy.mjs

@@ -0,0 +1,10 @@
+function keyBy(map, getKeyFromEntry) {
+    const result = new Map();
+    for (const [key, value] of map) {
+        const newKey = getKeyFromEntry(value, key, map);
+        result.set(newKey, value);
+    }
+    return result;
+}
+
+export { keyBy };

package/dist/object/cloneDeepWith.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const getSymbols = require('../compat/_internal/getSymbols.js');
 const getTag = require('../compat/_internal/getTag.js');
 const tags = require('../compat/_internal/tags.js');
+const isBuffer = require('../predicate/isBuffer.js');
 const isPrimitive = require('../predicate/isPrimitive.js');
 const isTypedArray = require('../predicate/isTypedArray.js');
 
@@ -60,7 +61,7 @@ function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new
         }
         return result;
     }
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+    if (isBuffer.isBuffer(valueToClone)) {
         return valueToClone.subarray();
     }
     if (isTypedArray.isTypedArray(valueToClone)) {

package/dist/object/cloneDeepWith.mjs

@@ -1,6 +1,7 @@
 import { getSymbols } from '../compat/_internal/getSymbols.mjs';
 import { getTag } from '../compat/_internal/getTag.mjs';
 import { uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, symbolTag, stringTag, setTag, regexpTag, objectTag, numberTag, mapTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, float64ArrayTag, float32ArrayTag, dateTag, booleanTag, dataViewTag, arrayBufferTag, arrayTag, argumentsTag } from '../compat/_internal/tags.mjs';
+import { isBuffer } from '../predicate/isBuffer.mjs';
 import { isPrimitive } from '../predicate/isPrimitive.mjs';
 import { isTypedArray } from '../predicate/isTypedArray.mjs';
 
@@ -56,7 +57,7 @@ function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new
         }
         return result;
     }
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+    if (isBuffer(valueToClone)) {
         return valueToClone.subarray();
     }
     if (isTypedArray(valueToClone)) {

package/dist/predicate/isBuffer.js

@@ -2,8 +2,10 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const globalThis = require('../_internal/globalThis.js');
+
 function isBuffer(x) {
-    return typeof Buffer !== 'undefined' && Buffer.isBuffer(x);
+    return typeof globalThis.globalThis.Buffer !== 'undefined' && globalThis.globalThis.Buffer.isBuffer(x);
 }
 
 exports.isBuffer = isBuffer;

package/dist/predicate/isBuffer.mjs

@@ -1,5 +1,7 @@
+import { globalThis as globalThis_ } from '../_internal/globalThis.mjs';
+
 function isBuffer(x) {
-    return typeof Buffer !== 'undefined' && Buffer.isBuffer(x);
+    return typeof globalThis_.Buffer !== 'undefined' && globalThis_.Buffer.isBuffer(x);
 }
 
 export { isBuffer };

package/dist/predicate/isEqualWith.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const isBuffer = require('./isBuffer.js');
 const isPlainObject = require('./isPlainObject.js');
 const getSymbols = require('../compat/_internal/getSymbols.js');
 const getTag = require('../compat/_internal/getTag.js');
@@ -123,7 +124,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
             case tags.bigInt64ArrayTag:
             case tags.float32ArrayTag:
             case tags.float64ArrayTag: {
-                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+                if (isBuffer.isBuffer(a) !== isBuffer.isBuffer(b)) {
                     return false;
                 }
                 if (a.length !== b.length) {

package/dist/predicate/isEqualWith.mjs

@@ -1,3 +1,4 @@
+import { isBuffer } from './isBuffer.mjs';
 import { isPlainObject } from './isPlainObject.mjs';
 import { getSymbols } from '../compat/_internal/getSymbols.mjs';
 import { getTag } from '../compat/_internal/getTag.mjs';
@@ -119,7 +120,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
             case bigInt64ArrayTag:
             case float32ArrayTag:
             case float64ArrayTag: {
-                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+                if (isBuffer(a) !== isBuffer(b)) {
                     return false;
                 }
                 if (a.length !== b.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.45.1",
+  "version": "1.46.0-dev.1786+95111dd0",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",