es-toolkit 1.20.0 → 1.21.0-dev.662

package/dist/compat/index.js

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-CDtN9Y.js');
+const zipWith = require('../_chunk/zipWith-DEcUS4.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
 const rest$1 = require('../_chunk/rest-pUyjvl.js');
 const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-Bzkqyz.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-E_VMwB.js');
+const toMerged = require('../_chunk/toMerged-D-sLFv.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-BIekvL.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-1xFSnK.js');
 const string_index = require('../string/index.js');
 
 function castArray(value) {
@@ -473,7 +473,8 @@ function flatten(value, depth = 1) {
         return result;
     }
     const recursive = (arr, currentDepth) => {
-        for (const item of arr) {
+        for (let i = 0; i < arr.length; i++) {
+            const item = arr[i];
             if (currentDepth < flooredDepth &&
                 (Array.isArray(item) ||
                     Boolean(item?.[Symbol.isConcatSpreadable]) ||
@@ -561,7 +562,7 @@ const compareValues = (a, b, order) => {
 };
 
 function isSymbol(value) {
-    return typeof value === 'symbol' || (value != null && value instanceof Symbol);
+    return typeof value === 'symbol' || value instanceof Symbol;
 }
 
 const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
@@ -784,6 +785,13 @@ function bindKey(object, key, ...partialArgs) {
 const bindKeyPlaceholder = Symbol('bindKey.placeholder');
 bindKey.placeholder = bindKeyPlaceholder;
 
+function defer(func, ...args) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return setTimeout(func, 1, ...args);
+}
+
 function rest(func, start = func.length - 1) {
     start = Number.parseInt(start, 10);
     if (Number.isNaN(start) || start < 0) {
@@ -833,60 +841,52 @@ function curry(func, arity = func.length, guard) {
     if (Number.isNaN(arity) || arity < 1) {
         arity = 0;
     }
-    const wrapper = function (...partials) {
-        const holders = replaceHolders(partials);
-        const length = partials.length - holders.length;
+    const wrapper = function (...partialArgs) {
+        const holders = partialArgs.filter(item => item === curry.placeholder);
+        const length = partialArgs.length - holders.length;
         if (length < arity) {
-            return makeCurry(func, holders, arity - length, partials);
+            return makeCurry(func, arity - length, partialArgs);
         }
         if (this instanceof wrapper) {
-            return new func(...partials);
+            return new func(...partialArgs);
         }
-        return func.apply(this, partials);
+        return func.apply(this, partialArgs);
     };
     wrapper.placeholder = curryPlaceholder;
     return wrapper;
 }
-function makeCurry(func, holders, arity, partials) {
-    function wrapper(...args) {
-        const holdersCount = args.filter(item => item === curry.placeholder).length;
-        const length = args.length - holdersCount;
-        args = composeArgs(args, partials, holders);
+function makeCurry(func, arity, partialArgs) {
+    function wrapper(...providedArgs) {
+        const holders = providedArgs.filter(item => item === curry.placeholder);
+        const length = providedArgs.length - holders.length;
+        providedArgs = composeArgs(providedArgs, partialArgs);
         if (length < arity) {
-            const newHolders = replaceHolders(args);
-            return makeCurry(func, newHolders, arity - length, args);
+            return makeCurry(func, arity - length, providedArgs);
         }
         if (this instanceof wrapper) {
-            return new func(...args);
+            return new func(...providedArgs);
         }
-        return func.apply(this, args);
+        return func.apply(this, providedArgs);
     }
     wrapper.placeholder = curryPlaceholder;
     return wrapper;
 }
-function replaceHolders(args) {
-    const result = [];
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === curry.placeholder) {
-            result.push(i);
+function composeArgs(providedArgs, partialArgs) {
+    const args = [];
+    let startIndex = 0;
+    for (let i = 0; i < partialArgs.length; i++) {
+        const arg = partialArgs[i];
+        if (arg === curry.placeholder && startIndex < providedArgs.length) {
+            args.push(providedArgs[startIndex++]);
         }
-    }
-    return result;
-}
-function composeArgs(args, partials, holders) {
-    const result = [...partials];
-    const argsLength = args.length;
-    const holdersLength = holders.length;
-    let argsIndex = -1, leftIndex = partials.length, rangeLength = Math.max(argsLength - holdersLength, 0);
-    while (++argsIndex < holdersLength) {
-        if (argsIndex < argsLength) {
-            result[holders[argsIndex]] = args[argsIndex];
+        else {
+            args.push(arg);
         }
     }
-    while (rangeLength--) {
-        result[leftIndex++] = args[argsIndex++];
+    for (let i = startIndex; i < providedArgs.length; i++) {
+        args.push(providedArgs[i]);
     }
-    return result;
+    return args;
 }
 const curryPlaceholder = Symbol('curry.placeholder');
 curry.placeholder = curryPlaceholder;
@@ -953,7 +953,8 @@ function pick(obj, ...keysArr) {
         return {};
     }
     const result = {};
-    for (let keys of keysArr) {
+    for (let i = 0; i < keysArr.length; i++) {
+        let keys = keysArr[i];
         switch (typeof keys) {
             case 'object': {
                 if (!Array.isArray(keys)) {
@@ -1236,28 +1237,24 @@ function isObject(value) {
     return value !== null && (typeof value === 'object' || typeof value === 'function');
 }
 
-function isBoolean(x) {
-    if (x === true || x === false) {
-        return true;
-    }
-    if (typeof x === 'object' && x != null && isWeakSet$1.getTag(x) === '[object Boolean]') {
-        return true;
-    }
-    return false;
+function isBoolean(value) {
+    return typeof value === 'boolean' || value instanceof Boolean;
+}
+
+function isError(value) {
+    return isWeakSet$1.getTag(value) === '[object Error]';
+}
+
+function isFinite(value) {
+    return Number.isFinite(value);
 }
 
 function isRegExp(value) {
-    return isWeakSet$1.getTag(value) === '[object RegExp]';
+    return isWeakSet$1.isRegExp(value);
 }
 
 function isString(value) {
-    if (typeof value === 'string') {
-        return true;
-    }
-    if (typeof value === 'object' && value != null && isWeakSet$1.getTag(value) === '[object String]') {
-        return true;
-    }
-    return false;
+    return typeof value === 'string' || value instanceof String;
 }
 
 function isWeakMap(value) {
@@ -1275,7 +1272,9 @@ function conformsTo(target, source) {
     if (target == null) {
         return Object.keys(source).length === 0;
     }
-    for (const key of Object.keys(source)) {
+    const keys = Object.keys(source);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
         const predicate = source[key];
         const value = target[key];
         if ((value === undefined && !(key in target)) || !predicate(value)) {
@@ -1301,16 +1300,17 @@ function isSafeInteger(value) {
 }
 
 function isNumber(value) {
-    if (typeof value === 'object' && value != null && isWeakSet$1.getTag(value) === '[object Number]') {
-        return true;
-    }
-    return typeof value === 'number';
+    return typeof value === 'number' || value instanceof Number;
 }
 
 function isNaN(value) {
     return Number.isNaN(value);
 }
 
+function isArrayLikeObject(value) {
+    return toMerged.isObjectLike(value) && isArrayLike(value);
+}
+
 function toString(value) {
     if (value == null) {
         return '';
@@ -1364,12 +1364,16 @@ function endsWith(str, target, position = str.length) {
     return str.endsWith(target, position);
 }
 
+function pad(str, length, chars = ' ') {
+    return string_index.pad(toString(str), length, chars);
+}
+
 function padStart(str, length = 0, chars = ' ') {
-    return str.padStart(length, chars);
+    return toString(str).padStart(length, chars);
 }
 
 function padEnd(str, length = 0, chars = ' ') {
-    return str.padEnd(length, chars);
+    return toString(str).padEnd(length, chars);
 }
 
 function repeat(str, n) {
@@ -1455,7 +1459,8 @@ function clamp(value, bound1, bound2) {
 function max(items = []) {
     let maxElement = items[0];
     let max = undefined;
-    for (const element of items) {
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
         if (max == null || element > max) {
             max = element;
             maxElement = element;
@@ -1467,7 +1472,8 @@ function max(items = []) {
 function min(items = []) {
     let minElement = items[0];
     let min = undefined;
-    for (const element of items) {
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
         if (min == null || element < min) {
             min = element;
             minElement = element;
@@ -1513,6 +1519,121 @@ function parseInt(string, radix = 0, guard) {
     return Number.parseInt(string, radix);
 }
 
+function inRange(value, minimum, maximum) {
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (maximum != null && !maximum) {
+        maximum = 0;
+    }
+    if (minimum != null && typeof minimum !== 'number') {
+        minimum = Number(minimum);
+    }
+    if (maximum == null && minimum === 0) {
+        return false;
+    }
+    if (maximum != null && typeof maximum !== 'number') {
+        maximum = Number(maximum);
+    }
+    if (maximum != null && minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    if (minimum === maximum) {
+        return false;
+    }
+    return range.inRange(value, minimum, maximum);
+}
+
+function random(...args) {
+    let minimum = 0;
+    let maximum = 1;
+    let floating = false;
+    switch (args.length) {
+        case 1: {
+            if (typeof args[0] === 'boolean') {
+                floating = args[0];
+            }
+            else {
+                maximum = args[0];
+            }
+            break;
+        }
+        case 2: {
+            if (typeof args[1] === 'boolean') {
+                maximum = args[0];
+                floating = args[1];
+            }
+            else {
+                minimum = args[0];
+                maximum = args[1];
+            }
+        }
+        case 3: {
+            if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) {
+                minimum = 0;
+                maximum = args[0];
+                floating = false;
+            }
+            else {
+                minimum = args[0];
+                maximum = args[1];
+                floating = args[2];
+            }
+        }
+    }
+    if (typeof minimum !== 'number') {
+        minimum = Number(minimum);
+    }
+    if (typeof maximum !== 'number') {
+        minimum = Number(maximum);
+    }
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (!maximum) {
+        maximum = 0;
+    }
+    if (minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    if (minimum === maximum) {
+        return minimum;
+    }
+    if (floating) {
+        return randomInt.random(minimum, maximum + 1);
+    }
+    else {
+        return randomInt.randomInt(minimum, maximum + 1);
+    }
+}
+
+function toNumber(value) {
+    if (isSymbol(value)) {
+        return NaN;
+    }
+    return Number(value);
+}
+
+function toFinite(value) {
+    if (!value) {
+        return value === 0 ? value : 0;
+    }
+    value = toNumber(value);
+    if (value === Infinity || value === -Infinity) {
+        const sign = value < 0 ? -1 : 1;
+        return sign * Number.MAX_VALUE;
+    }
+    return value === value ? value : 0;
+}
+
+function toInteger(value) {
+    const finite = toFinite(value);
+    const remainder = finite % 1;
+    return remainder ? finite - remainder : finite;
+}
+
 exports.at = zipWith.at;
 exports.compact = zipWith.compact;
 exports.countBy = zipWith.countBy;
@@ -1576,37 +1697,33 @@ exports.once = rest$1.once;
 exports.partial = rest$1.partial;
 exports.partialRight = rest$1.partialRight;
 exports.unary = rest$1.unary;
-exports.inRange = range.inRange;
 exports.mean = range.mean;
 exports.meanBy = range.meanBy;
 exports.range = range.range;
 exports.sum = range.sum;
 exports.sumBy = range.sumBy;
-exports.random = randomInt.random;
 exports.randomInt = randomInt.randomInt;
 exports.clone = toMerged.clone;
-exports.cloneDeep = toMerged.cloneDeep;
 exports.flattenObject = toMerged.flattenObject;
 exports.invert = toMerged.invert;
 exports.isObjectLike = toMerged.isObjectLike;
 exports.omitBy = toMerged.omitBy;
 exports.pickBy = toMerged.pickBy;
 exports.toMerged = toMerged.toMerged;
+exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.isDate = isWeakSet$1.isDate;
 exports.isEqual = isWeakSet$1.isEqual;
 exports.isFunction = isWeakSet$1.isFunction;
 exports.isLength = isWeakSet$1.isLength;
-exports.isNil = isWeakSet$1.isNil;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isUndefined = isWeakSet$1.isUndefined;
-exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.capitalize = string_index.capitalize;
+exports.constantCase = string_index.constantCase;
 exports.deburr = string_index.deburr;
 exports.escape = string_index.escape;
 exports.escapeRegExp = string_index.escapeRegExp;
 exports.lowerFirst = string_index.lowerFirst;
-exports.pad = string_index.pad;
 exports.pascalCase = string_index.pascalCase;
 exports.unescape = string_index.unescape;
 exports.upperFirst = string_index.upperFirst;
@@ -1619,11 +1736,13 @@ exports.castArray = castArray;
 exports.ceil = ceil;
 exports.chunk = chunk;
 exports.clamp = clamp;
+exports.cloneDeep = cloneDeep;
 exports.concat = concat;
 exports.conforms = conforms;
 exports.conformsTo = conformsTo;
 exports.curry = curry;
 exports.debounce = debounce;
+exports.defer = defer;
 exports.difference = difference;
 exports.drop = drop;
 exports.endsWith = endsWith;
@@ -1638,14 +1757,19 @@ exports.floor = floor;
 exports.fromPairs = fromPairs;
 exports.get = get;
 exports.has = has;
+exports.inRange = inRange;
 exports.indexOf = indexOf;
 exports.isArguments = isArguments;
 exports.isArray = isArray;
 exports.isArrayLike = isArrayLike;
+exports.isArrayLikeObject = isArrayLikeObject;
 exports.isBoolean = isBoolean;
+exports.isError = isError;
+exports.isFinite = isFinite;
 exports.isInteger = isInteger;
 exports.isMatch = isMatch;
 exports.isNaN = isNaN;
+exports.isNil = isNil;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;
@@ -1669,11 +1793,13 @@ exports.mergeWith = mergeWith;
 exports.min = min;
 exports.omit = omit;
 exports.orderBy = orderBy;
+exports.pad = pad;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.parseInt = parseInt;
 exports.pick = pick;
 exports.property = property;
+exports.random = random;
 exports.rearg = rearg;
 exports.repeat = repeat;
 exports.rest = rest;
@@ -1687,6 +1813,9 @@ exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;
 exports.throttle = throttle;
+exports.toFinite = toFinite;
+exports.toInteger = toInteger;
+exports.toNumber = toNumber;
 exports.toPath = toPath;
 exports.toString = toString;
 exports.trim = trim;

package/dist/compat/index.mjs

@@ -57,10 +57,8 @@ 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 { inRange } from '../math/inRange.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
-export { random } from '../math/random.mjs';
 export { randomInt } from '../math/randomInt.mjs';
 export { sum } from '../math/sum.mjs';
 export { sumBy } from '../math/sumBy.mjs';
@@ -70,30 +68,28 @@ 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 { cloneDeep } from '../object/cloneDeep.mjs';
+export { isPrimitive } from '../predicate/isPrimitive.mjs';
 export { isObjectLike } from './predicate/isObjectLike.mjs';
 export { toMerged } from '../object/toMerged.mjs';
 export { isDate } from '../predicate/isDate.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
-export { isNil } from '../predicate/isNil.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 { isFunction } from '../predicate/isFunction.mjs';
-export { isPrimitive } from '../predicate/isPrimitive.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { timeout } from '../promise/timeout.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 { unescape } from '../string/unescape.mjs';
-export { pad } from '../string/pad.mjs';
 export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
 export { concat } from './array/concat.mjs';
@@ -116,6 +112,7 @@ export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { ary } from './function/ary.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';
@@ -135,6 +132,7 @@ export { merge } from './object/merge.mjs';
 export { mergeWith } from './object/mergeWith.mjs';
 export { fromPairs } from './object/fromPairs.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 { isArguments } from './predicate/isArguments.mjs';
@@ -142,6 +140,8 @@ export { isArrayLike } from './predicate/isArrayLike.mjs';
 export { isSymbol } from './predicate/isSymbol.mjs';
 export { isObject } from './predicate/isObject.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
+export { isError } from './predicate/isError.mjs';
+export { isFinite } from './predicate/isFinite.mjs';
 export { isTypedArray } from './predicate/isTypedArray.mjs';
 export { isMatch } from './predicate/isMatch.mjs';
 export { isRegExp } from './predicate/isRegExp.mjs';
@@ -156,6 +156,8 @@ 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 { camelCase } from './string/camelCase.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
 export { snakeCase } from './string/snakeCase.mjs';
@@ -164,6 +166,7 @@ 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 { repeat } from './string/repeat.mjs';
@@ -177,5 +180,10 @@ 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 { 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/math/inRange.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Checks if the value is less than the maximum.
+ *
+ * @param {number} value The value to check.
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 5); // result will be true.
+ * const result2 = inRange(5, 5); // result2 will be false.
+ */
+declare function inRange(value: number, maximum: number): boolean;
+/**
+ * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} value The value to check.
+ * @param {number} minimum The lower bound of the range (inclusive).
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 2, 5); // result will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ */
+declare function inRange(value: number, minimum: number, maximum: number): boolean;
+
+export { inRange };

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

@@ -0,0 +1,27 @@
+/**
+ * Checks if the value is less than the maximum.
+ *
+ * @param {number} value The value to check.
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 5); // result will be true.
+ * const result2 = inRange(5, 5); // result2 will be false.
+ */
+declare function inRange(value: number, maximum: number): boolean;
+/**
+ * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} value The value to check.
+ * @param {number} minimum The lower bound of the range (inclusive).
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 2, 5); // result will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ */
+declare function inRange(value: number, minimum: number, maximum: number): boolean;
+
+export { inRange };

package/dist/compat/math/inRange.mjs

@@ -0,0 +1,28 @@
+import { inRange as inRange$1 } from '../../math/inRange.mjs';
+
+function inRange(value, minimum, maximum) {
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (maximum != null && !maximum) {
+        maximum = 0;
+    }
+    if (minimum != null && typeof minimum !== 'number') {
+        minimum = Number(minimum);
+    }
+    if (maximum == null && minimum === 0) {
+        return false;
+    }
+    if (maximum != null && typeof maximum !== 'number') {
+        maximum = Number(maximum);
+    }
+    if (maximum != null && minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    if (minimum === maximum) {
+        return false;
+    }
+    return inRange$1(value, minimum, maximum);
+}
+
+export { inRange };

package/dist/compat/math/max.mjs

@@ -1,7 +1,8 @@
 function max(items = []) {
     let maxElement = items[0];
     let max = undefined;
-    for (const element of items) {
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
         if (max == null || element > max) {
             max = element;
             maxElement = element;

package/dist/compat/math/min.mjs

@@ -1,7 +1,8 @@
 function min(items = []) {
     let minElement = items[0];
     let min = undefined;
-    for (const element of items) {
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
         if (min == null || element < min) {
             min = element;
             minElement = element;