es-toolkit 1.27.0 → 1.28.0-dev.910

package/dist/compat/index.js

@@ -8,10 +8,10 @@ const unary = require('../_chunk/unary-CcTNuC.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
 const rangeRight = require('../_chunk/rangeRight-w3WrXN.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-CPY8Ug.js');
+const toMerged = require('../_chunk/toMerged-AV73JV.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-octpoD.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-D8h8bS.js');
-const upperFirst = require('../_chunk/upperFirst-DK_rTF.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-CvIdTA.js');
+const upperFirst = require('../_chunk/upperFirst-CorAVn.js');
 const util_index = require('../util/index.js');
 
 function castArray(value) {
@@ -21,7 +21,7 @@ function castArray(value) {
     return Array.isArray(value) ? value : [value];
 }
 
-function toArray(value) {
+function toArray$1(value) {
     return Array.isArray(value) ? value : Array.from(value);
 }
 
@@ -34,7 +34,7 @@ function chunk(arr, size = 1) {
     if (size === 0 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.chunk(toArray(arr), size);
+    return zipWith.chunk(toArray$1(arr), size);
 }
 
 function compact(arr) {
@@ -56,7 +56,7 @@ function difference(arr, ...values) {
     if (!isArrayLikeObject(arr)) {
         return [];
     }
-    const arr1 = toArray(arr);
+    const arr1 = toArray$1(arr);
     const arr2 = [];
     for (let i = 0; i < values.length; i++) {
         const value = values[i];
@@ -71,7 +71,7 @@ function last(array) {
     if (!isArrayLike(array)) {
         return undefined;
     }
-    return zipWith.last(toArray(array));
+    return zipWith.last(toArray$1(array));
 }
 
 function flattenArrayLike(values) {
@@ -354,29 +354,39 @@ function matches(source) {
     };
 }
 
-function cloneDeep(obj) {
-    if (typeof obj !== 'object') {
-        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());
-            toMerged.copyProperties(result, obj);
-            return result;
+function cloneDeepWith(obj, cloneValue) {
+    return toMerged.cloneDeepWith(obj, (value, key, object, stack) => {
+        const cloned = cloneValue?.(value, key, object, stack);
+        if (cloned != null) {
+            return cloned;
         }
-        case isWeakSet$1.argumentsTag: {
-            const result = {};
-            toMerged.copyProperties(result, obj);
-            result.length = obj.length;
-            result[Symbol.iterator] = obj[Symbol.iterator];
-            return result;
+        if (typeof obj !== 'object') {
+            return undefined;
         }
-        default: {
-            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());
+                toMerged.copyProperties(result, obj);
+                return result;
+            }
+            case isWeakSet$1.argumentsTag: {
+                const result = {};
+                toMerged.copyProperties(result, obj);
+                result.length = obj.length;
+                result[Symbol.iterator] = obj[Symbol.iterator];
+                return result;
+            }
+            default: {
+                return undefined;
+            }
         }
-    }
+    });
+}
+
+function cloneDeep(obj) {
+    return cloneDeepWith(obj);
 }
 
 const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
@@ -520,7 +530,7 @@ function drop(collection, itemsCount = 1, guard) {
         return [];
     }
     itemsCount = guard ? 1 : toInteger(itemsCount);
-    return zipWith.drop(toArray(collection), itemsCount);
+    return zipWith.drop(toArray$1(collection), itemsCount);
 }
 
 function dropRight(collection, itemsCount = 1, guard) {
@@ -528,7 +538,7 @@ function dropRight(collection, itemsCount = 1, guard) {
         return [];
     }
     itemsCount = guard ? 1 : toInteger(itemsCount);
-    return zipWith.dropRight(toArray(collection), itemsCount);
+    return zipWith.dropRight(toArray$1(collection), itemsCount);
 }
 
 function dropRightWhile(arr, predicate) {
@@ -552,6 +562,8 @@ function dropRightWhileImpl(arr, predicate) {
                 return zipWith.dropRightWhile(arr, matches(predicate));
             }
         }
+        case 'symbol':
+        case 'number':
         case 'string': {
             return zipWith.dropRightWhile(arr, property(predicate));
         }
@@ -562,7 +574,7 @@ function dropWhile(arr, predicate) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return dropWhileImpl(toArray(arr), predicate);
+    return dropWhileImpl(toArray$1(arr), predicate);
 }
 function dropWhileImpl(arr, predicate) {
     switch (typeof predicate) {
@@ -579,6 +591,8 @@ function dropWhileImpl(arr, predicate) {
                 return zipWith.dropWhile(arr, matches(predicate));
             }
         }
+        case 'number':
+        case 'symbol':
         case 'string': {
             return zipWith.dropWhile(arr, property(predicate));
         }
@@ -632,6 +646,8 @@ function every(source, doesMatch, guard) {
                 return values.every(matches(doesMatch));
             }
         }
+        case 'symbol':
+        case 'number':
         case 'string': {
             return values.every(property(doesMatch));
         }
@@ -693,6 +709,8 @@ function filter(source, predicate) {
                 ? collection.filter(matchesProperty(predicate[0], predicate[1]))
                 : collection.filter(matches(predicate));
         }
+        case 'symbol':
+        case 'number':
         case 'string': {
             return collection.filter(property(predicate));
         }
@@ -729,6 +747,8 @@ function find(source, doesMatch) {
                 return values.find(matches(doesMatch));
             }
         }
+        case 'symbol':
+        case 'number':
         case 'string': {
             return values.find(property(doesMatch));
         }
@@ -760,6 +780,8 @@ function findIndex(arr, doesMatch, fromIndex = 0) {
             }
             break;
         }
+        case 'number':
+        case 'symbol':
         case 'string': {
             index = subArray.findIndex(property(doesMatch));
         }
@@ -777,7 +799,7 @@ function findLastIndex(arr, doesMatch, fromIndex = arr ? arr.length - 1 : 0) {
     else {
         fromIndex = Math.min(fromIndex, arr.length - 1);
     }
-    const subArray = toArray(arr).slice(0, fromIndex + 1);
+    const subArray = toArray$1(arr).slice(0, fromIndex + 1);
     switch (typeof doesMatch) {
         case 'function': {
             return subArray.findLastIndex(doesMatch);
@@ -792,6 +814,8 @@ function findLastIndex(arr, doesMatch, fromIndex = arr ? arr.length - 1 : 0) {
                 return subArray.findLastIndex(matches(doesMatch));
             }
         }
+        case 'number':
+        case 'symbol':
         case 'string': {
             return subArray.findLastIndex(property(doesMatch));
         }
@@ -855,7 +879,7 @@ function head(arr) {
     if (!isArrayLike(arr)) {
         return undefined;
     }
-    return zipWith.head(toArray(arr));
+    return zipWith.head(toArray$1(arr));
 }
 
 function includes(source, target, fromIndex, guard) {
@@ -1091,7 +1115,7 @@ function sample(collection) {
         return undefined;
     }
     if (isArrayLike(collection)) {
-        return zipWith.sample(toArray(collection));
+        return zipWith.sample(toArray$1(collection));
     }
     return zipWith.sample(Object.values(collection));
 }
@@ -1176,6 +1200,8 @@ function some(source, predicate, guard) {
                 return values.some(matches(predicate));
             }
         }
+        case 'number':
+        case 'symbol':
         case 'string': {
             return values.some(property(predicate));
         }
@@ -1197,7 +1223,7 @@ function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return zipWith.tail(toArray(arr));
+    return zipWith.tail(toArray$1(arr));
 }
 
 function take(arr, count = 1, guard) {
@@ -1205,7 +1231,7 @@ function take(arr, count = 1, guard) {
     if (count < 1 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.take(toArray(arr), count);
+    return zipWith.take(toArray$1(arr), count);
 }
 
 function takeRight(arr, count = 1, guard) {
@@ -1213,7 +1239,7 @@ function takeRight(arr, count = 1, guard) {
     if (count <= 0 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.takeRight(toArray(arr), count);
+    return zipWith.takeRight(toArray$1(arr), count);
 }
 
 function union(...arrays) {
@@ -1229,21 +1255,11 @@ function uniq(arr) {
     return zipWith.uniq(Array.from(arr));
 }
 
-function uniqBy(arr, ...values) {
-    if (!isArrayLikeObject(arr)) {
+function uniqBy(array, iteratee$1) {
+    if (!isArrayLikeObject(array)) {
         return [];
     }
-    const iteratee$1 = last(values);
-    if (iteratee$1 === undefined) {
-        return Array.from(arr);
-    }
-    const validArrays = values.slice(0, -1).filter(isArrayLikeObject);
-    const flattenedArrays = flatten(validArrays);
-    const allValues = [...Array.from(arr), ...flattenedArrays];
-    if (isArrayLikeObject(iteratee$1)) {
-        return zipWith.uniq(allValues);
-    }
-    return zipWith.uniqBy(allValues, iteratee(iteratee$1));
+    return zipWith.uniqBy(Array.from(array), iteratee(iteratee$1));
 }
 
 function unzip(array) {
@@ -1624,7 +1640,16 @@ function throttle(func, throttleMs = 0, options = {}) {
         options = {};
     }
     const { leading = true, trailing = true, signal } = options;
-    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+    return debounce(func, throttleMs, {
+        leading,
+        trailing,
+        signal,
+        maxWait: throttleMs,
+    });
+}
+
+function add(value, other) {
+    return value + other;
 }
 
 function decimalAdjust(type, number, precision = 0) {
@@ -1811,6 +1836,90 @@ function sum(array) {
     return sumBy(array);
 }
 
+function isPrototype(value) {
+    const constructor = value.constructor;
+    const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype;
+    return value === prototype;
+}
+
+function isTypedArray(x) {
+    return isPlainObject$1.isTypedArray(x);
+}
+
+function times(n, getValue) {
+    n = toInteger(n);
+    if (n < 1 || !Number.isSafeInteger(n)) {
+        return [];
+    }
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+        result[i] = typeof getValue === 'function' ? getValue(i) : i;
+    }
+    return result;
+}
+
+function keysIn(object) {
+    if (object == null) {
+        return [];
+    }
+    switch (typeof object) {
+        case 'object':
+        case 'function': {
+            if (isArrayLike(object)) {
+                return arrayLikeKeysIn(object);
+            }
+            if (isPrototype(object)) {
+                return prototypeKeysIn(object);
+            }
+            return keysInImpl(object);
+        }
+        default: {
+            return keysInImpl(Object(object));
+        }
+    }
+}
+function keysInImpl(object) {
+    const result = [];
+    for (const key in object) {
+        result.push(key);
+    }
+    return result;
+}
+function prototypeKeysIn(object) {
+    const keys = keysInImpl(object);
+    return keys.filter(key => key !== 'constructor');
+}
+function arrayLikeKeysIn(object) {
+    const indices = times(object.length, index => `${index}`);
+    const filteredKeys = new Set(indices);
+    if (isWeakSet$1.isBuffer(object)) {
+        filteredKeys.add('offset');
+        filteredKeys.add('parent');
+    }
+    if (isTypedArray(object)) {
+        filteredKeys.add('buffer');
+        filteredKeys.add('byteLength');
+        filteredKeys.add('byteOffset');
+    }
+    return [...indices, ...keysInImpl(object).filter(key => !filteredKeys.has(key))];
+}
+
+function assignIn(object, ...sources) {
+    for (let i = 0; i < sources.length; i++) {
+        assignInImpl(object, sources[i]);
+    }
+    return object;
+}
+function assignInImpl(object, source) {
+    const keys = keysIn(source);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (!isWeakSet$1.eq(object[key], source[key])) {
+            object[key] = source[key];
+        }
+    }
+}
+
 function defaults(object, ...sources) {
     object = Object(object);
     const objectProto = Object.prototype;
@@ -1921,10 +2030,6 @@ function isPlainObject(object) {
     return Object.getPrototypeOf(object) === proto;
 }
 
-function isTypedArray(x) {
-    return isPlainObject$1.isTypedArray(x);
-}
-
 function mergeWith(object, ...otherArgs) {
     const sources = otherArgs.slice(0, -1);
     const merge = otherArgs[otherArgs.length - 1];
@@ -2179,10 +2284,8 @@ function isDate(value) {
     return isWeakSet$1.isDate(value);
 }
 
-function isPrototype(value) {
-    const constructor = value.constructor;
-    const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype;
-    return value === prototype;
+function isElement(value) {
+    return toMerged.isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
 }
 
 function isEmpty(value) {
@@ -2444,6 +2547,10 @@ function template(string, options, guard) {
     return result;
 }
 
+function toUpper(value) {
+    return toString(value).toUpperCase();
+}
+
 function trim(str, chars, guard) {
     if (str == null) {
         return '';
@@ -2457,7 +2564,7 @@ function trim(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trim(str, chars.map(x => x.toString()));
+                return upperFirst.trim(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return upperFirst.trim(str, chars.toString().split(''));
@@ -2479,7 +2586,7 @@ function trimEnd(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trimEnd(str, chars.map(x => x.toString()));
+                return upperFirst.trimEnd(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return upperFirst.trimEnd(str, chars.toString().split(''));
@@ -2501,7 +2608,7 @@ function trimStart(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trimStart(str, chars.map(x => x.toString()));
+                return upperFirst.trimStart(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return upperFirst.trimStart(str, chars.toString().split(''));
@@ -2514,6 +2621,12 @@ function upperCase(str) {
     return upperFirst.upperCase(normalizeForCase(str));
 }
 
+function words(str, pattern = upperFirst.CASE_SPLIT_PATTERN) {
+    const input = toString(str);
+    const words = Array.from(input.match(pattern) ?? []);
+    return words.filter(x => x !== '');
+}
+
 function constant(value) {
     return () => value;
 }
@@ -2525,16 +2638,34 @@ function defaultTo(value, defaultValue) {
     return value;
 }
 
-function times(n, getValue) {
-    n = toInteger(n);
-    if (n < 1 || !Number.isSafeInteger(n)) {
+function gt(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value > other;
+    }
+    return toNumber(value) > toNumber(other);
+}
+
+function gte(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value >= other;
+    }
+    return toNumber(value) >= toNumber(other);
+}
+
+function toArray(value) {
+    if (value == null) {
         return [];
     }
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-        result[i] = typeof getValue === 'function' ? getValue(i) : i;
+    if (isArrayLike(value) || isMap(value)) {
+        return Array.from(value);
     }
-    return result;
+    if (typeof value === 'string') {
+        return value.split('');
+    }
+    if (typeof value === 'object') {
+        return Object.values(value);
+    }
+    return [];
 }
 
 const MAX_ARRAY_LENGTH = 4_294_967_295;
@@ -2624,6 +2755,7 @@ exports.toMerged = toMerged.toMerged;
 exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.eq = isWeakSet$1.eq;
 exports.isBlob = isWeakSet$1.isBlob;
+exports.isBuffer = isWeakSet$1.isBuffer;
 exports.isEqual = isWeakSet$1.isEqual;
 exports.isFile = isWeakSet$1.isFile;
 exports.isFunction = isWeakSet$1.isFunction;
@@ -2642,9 +2774,10 @@ exports.lowerFirst = upperFirst.lowerFirst;
 exports.pascalCase = upperFirst.pascalCase;
 exports.unescape = upperFirst.unescape;
 exports.upperFirst = upperFirst.upperFirst;
-exports.words = upperFirst.words;
 exports.invariant = util_index.invariant;
+exports.add = add;
 exports.ary = ary;
+exports.assignIn = assignIn;
 exports.attempt = attempt;
 exports.before = before;
 exports.bind = bind;
@@ -2655,6 +2788,7 @@ exports.ceil = ceil;
 exports.chunk = chunk;
 exports.clamp = clamp;
 exports.cloneDeep = cloneDeep;
+exports.cloneDeepWith = cloneDeepWith;
 exports.compact = compact;
 exports.concat = concat;
 exports.conforms = conforms;
@@ -2676,6 +2810,7 @@ exports.each = forEach;
 exports.endsWith = endsWith;
 exports.escape = escape;
 exports.every = every;
+exports.extend = assignIn;
 exports.fill = fill;
 exports.filter = filter;
 exports.find = find;
@@ -2692,6 +2827,8 @@ exports.flowRight = flowRight;
 exports.forEach = forEach;
 exports.fromPairs = fromPairs;
 exports.get = get;
+exports.gt = gt;
+exports.gte = gte;
 exports.has = has;
 exports.head = head;
 exports.inRange = inRange;
@@ -2707,6 +2844,7 @@ exports.isArrayLike = isArrayLike;
 exports.isArrayLikeObject = isArrayLikeObject;
 exports.isBoolean = isBoolean;
 exports.isDate = isDate;
+exports.isElement = isElement;
 exports.isEmpty = isEmpty;
 exports.isEqualWith = isEqualWith;
 exports.isError = isError;
@@ -2730,6 +2868,7 @@ exports.isWeakSet = isWeakSet;
 exports.iteratee = iteratee;
 exports.join = join;
 exports.kebabCase = kebabCase;
+exports.keysIn = keysIn;
 exports.last = last;
 exports.lowerCase = lowerCase;
 exports.mapKeys = mapKeys;
@@ -2773,6 +2912,7 @@ exports.template = template;
 exports.templateSettings = templateSettings;
 exports.throttle = throttle;
 exports.times = times;
+exports.toArray = toArray;
 exports.toDefaulted = toDefaulted;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;
@@ -2781,6 +2921,7 @@ exports.toNumber = toNumber;
 exports.toPath = toPath;
 exports.toSafeInteger = toSafeInteger;
 exports.toString = toString;
+exports.toUpper = toUpper;
 exports.trim = trim;
 exports.trimEnd = trimEnd;
 exports.trimStart = trimStart;
@@ -2792,5 +2933,6 @@ exports.unset = unset;
 exports.unzip = unzip;
 exports.upperCase = upperCase;
 exports.without = without;
+exports.words = words;
 exports.zip = zip;
 exports.zipObjectDeep = zipObjectDeep;

package/dist/compat/index.mjs

@@ -56,6 +56,7 @@ 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 { isBuffer } from '../predicate/isBuffer.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { eq } from './util/eq.mjs';
 export { isFile } from '../predicate/isFile.mjs';
@@ -69,7 +70,6 @@ export { delay } from '../promise/delay.mjs';
 export { timeout } from '../promise/timeout.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
-export { words } from '../string/words.mjs';
 export { constantCase } from '../string/constantCase.mjs';
 export { deburr } from '../string/deburr.mjs';
 export { escapeRegExp } from '../string/escapeRegExp.mjs';
@@ -137,6 +137,7 @@ 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 { add } from './math/add.mjs';
 export { ceil } from './math/ceil.mjs';
 export { clamp } from './math/clamp.mjs';
 export { floor } from './math/floor.mjs';
@@ -148,12 +149,15 @@ export { random } from './math/random.mjs';
 export { round } from './math/round.mjs';
 export { sum } from './math/sum.mjs';
 export { sumBy } from './math/sumBy.mjs';
+export { assignIn, assignIn as extend } from './object/assignIn.mjs';
 export { cloneDeep } from './object/cloneDeep.mjs';
+export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { defaults } from './object/defaults.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
 export { invertBy } from './object/invertBy.mjs';
+export { keysIn } from './object/keysIn.mjs';
 export { mapKeys } from './object/mapKeys.mjs';
 export { mapValues } from './object/mapValues.mjs';
 export { merge } from './object/merge.mjs';
@@ -173,6 +177,7 @@ export { isArrayLike } from './predicate/isArrayLike.mjs';
 export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isDate } from './predicate/isDate.mjs';
+export { isElement } from './predicate/isElement.mjs';
 export { isEmpty } from './predicate/isEmpty.mjs';
 export { isEqualWith } from './predicate/isEqualWith.mjs';
 export { isError } from './predicate/isError.mjs';
@@ -209,14 +214,19 @@ export { snakeCase } from './string/snakeCase.mjs';
 export { startCase } from './string/startCase.mjs';
 export { startsWith } from './string/startsWith.mjs';
 export { template, templateSettings } from './string/template.mjs';
+export { toUpper } from './string/toUpper.mjs';
 export { trim } from './string/trim.mjs';
 export { trimEnd } from './string/trimEnd.mjs';
 export { trimStart } from './string/trimStart.mjs';
 export { upperCase } from './string/upperCase.mjs';
+export { words } from './string/words.mjs';
 export { constant } from './util/constant.mjs';
 export { defaultTo } from './util/defaultTo.mjs';
+export { gt } from './util/gt.mjs';
+export { gte } from './util/gte.mjs';
 export { iteratee } from './util/iteratee.mjs';
 export { times } from './util/times.mjs';
+export { toArray } from './util/toArray.mjs';
 export { toFinite } from './util/toFinite.mjs';
 export { toInteger } from './util/toInteger.mjs';
 export { toLength } from './util/toLength.mjs';

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

@@ -0,0 +1,18 @@
+/**
+ * Adds two numbers while safely handling `NaN` values.
+ *
+ * This function takes two numbers and returns their sum. If either of the numbers is `NaN`,
+ * the function returns `NaN`.
+ *
+ * @param {number} value - The first number to add.
+ * @param {number} other - The second number to add.
+ * @returns {number} The sum of the two numbers, or `NaN` if any input is `NaN`.
+ *
+ * @example
+ * const result1 = add(2, 3);    // result1 will be 5
+ * const result2 = add(5, NaN);  // result2 will be NaN
+ * const result3 = add(NaN, 10); // result3 will be NaN
+ */
+declare function add(value: number, other: number): number;
+
+export { add };

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

@@ -0,0 +1,18 @@
+/**
+ * Adds two numbers while safely handling `NaN` values.
+ *
+ * This function takes two numbers and returns their sum. If either of the numbers is `NaN`,
+ * the function returns `NaN`.
+ *
+ * @param {number} value - The first number to add.
+ * @param {number} other - The second number to add.
+ * @returns {number} The sum of the two numbers, or `NaN` if any input is `NaN`.
+ *
+ * @example
+ * const result1 = add(2, 3);    // result1 will be 5
+ * const result2 = add(5, NaN);  // result2 will be NaN
+ * const result3 = add(NaN, 10); // result3 will be NaN
+ */
+declare function add(value: number, other: number): number;
+
+export { add };

package/dist/compat/math/add.mjs

@@ -0,0 +1,5 @@
+function add(value, other) {
+    return value + other;
+}
+
+export { add };