es-toolkit 1.33.0 → 1.34.0-dev.1075

package/dist/compat/index.js

@@ -11,10 +11,10 @@ const range$1 = require('../_chunk/range-HnEIT7.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-CwnQF6.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-Xaozpc.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-TIM260.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-C2NpfO.js');
 const promise_index = require('../promise/index.js');
 const upperFirst$1 = require('../_chunk/upperFirst-nA5L7X.js');
-const util_index = require('../util/index.js');
+const invariant = require('../_chunk/invariant-BfGFfr.js');
 
 function castArray(value) {
     if (arguments.length === 0) {
@@ -103,7 +103,10 @@ function isDeepKey(key) {
 }
 
 function toKey(value) {
-    if (Object.is(value, -0)) {
+    if (typeof value === 'string' || typeof value === 'symbol') {
+        return value;
+    }
+    if (Object.is(value.valueOf(), -0)) {
         return '-0';
     }
     return value.toString();
@@ -695,37 +698,22 @@ function filter(source, predicate) {
     if (!source) {
         return [];
     }
-    if (!predicate) {
-        predicate = unary.identity;
-    }
     const collection = isArray(source) ? source : Object.values(source);
-    switch (typeof predicate) {
-        case 'function': {
-            if (!Array.isArray(source)) {
-                const result = [];
-                const keys = Object.keys(source);
-                for (let i = 0; i < keys.length; i++) {
-                    const key = keys[i];
-                    const value = source[key];
-                    if (predicate(value, key, source)) {
-                        result.push(value);
-                    }
-                }
-                return result;
+    predicate = iteratee(predicate);
+    if (!Array.isArray(source)) {
+        const result = [];
+        const keys = Object.keys(source);
+        const length = isArrayLike(source) ? source.length : keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            const value = source[key];
+            if (predicate(value, key, source)) {
+                result.push(value);
             }
-            return collection.filter(predicate);
-        }
-        case 'object': {
-            return isArray(predicate)
-                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
-                : collection.filter(matches(predicate));
-        }
-        case 'symbol':
-        case 'number':
-        case 'string': {
-            return collection.filter(property(predicate));
         }
+        return result;
     }
+    return collection.filter(predicate);
 }
 
 function find(source, _doesMatch, fromIndex = 0) {
@@ -1014,7 +1002,6 @@ function uniq(arr) {
 }
 
 function intersectionWith(firstArr, ...otherArrs) {
-    console.log(firstArr);
     if (firstArr == null) {
         return [];
     }
@@ -1147,7 +1134,7 @@ function isKey(value, object) {
         return true;
     }
     return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) ||
-        (object != null));
+        (object != null && Object.hasOwn(object, value)));
 }
 
 function orderBy(collection, criteria, orders, guard) {
@@ -1312,6 +1299,19 @@ function reduceRight(collection, iteratee = unary.identity, accumulator) {
     return accumulator;
 }
 
+function negate(func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return function (...args) {
+        return !func.apply(this, args);
+    };
+}
+
+function reject(source, predicate) {
+    return filter(source, negate(iteratee(predicate)));
+}
+
 function remove(arr, shouldRemoveElement) {
     return zipWith.remove(arr, iteratee(shouldRemoveElement));
 }
@@ -1516,6 +1516,17 @@ function sortedIndex(array, value) {
     return sortedIndexBy(array, value, value => value);
 }
 
+function sortedIndexOf(array, value) {
+    if (!array?.length) {
+        return -1;
+    }
+    const index = sortedIndex(array, value);
+    if (index < array.length && isWeakSet$1.eq(array[index], value)) {
+        return index;
+    }
+    return -1;
+}
+
 function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
@@ -1585,19 +1596,35 @@ function zip(...arrays) {
     return zipWith.zip(...arrays.filter(group => isArrayLikeObject(group)));
 }
 
+const assignValue = (object, key, value) => {
+    const objValue = object[key];
+    if (!(Object.hasOwn(object, key) && isWeakSet$1.eq(objValue, value)) || (value === undefined && !(key in object))) {
+        object[key] = value;
+    }
+};
+
 function set(obj, path, value) {
-    const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
+    if (obj == null && !isObject(obj)) {
+        return obj;
+    }
+    const resolvedPath = isKey(path, obj)
+        ? [path]
+        : Array.isArray(path)
+            ? path
+            : typeof path === 'string'
+                ? toPath(path)
+                : [path];
     let current = obj;
-    for (let i = 0; i < resolvedPath.length - 1; i++) {
-        const key = resolvedPath[i];
-        const nextKey = resolvedPath[i + 1];
-        if (current[key] == null) {
-            current[key] = isIndex(nextKey) ? [] : {};
-        }
+    for (let i = 0; i < resolvedPath.length && current != null; i++) {
+        const key = toKey(resolvedPath[i]);
+        let newValue = value;
+        if (i !== resolvedPath.length - 1) {
+            const objValue = current[key];
+            newValue = isObject(objValue) ? objValue : isIndex(resolvedPath[i + 1]) ? [] : {};
+        }
+        assignValue(current, key, newValue);
         current = current[key];
     }
-    const lastKey = resolvedPath[resolvedPath.length - 1];
-    current[lastKey] = value;
     return obj;
 }
 
@@ -1919,15 +1946,6 @@ function flowRight(...funcs) {
     return unary.flowRight(...flattenFuncs);
 }
 
-function negate(func) {
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    return function (...args) {
-        return !func.apply(this, args);
-    };
-}
-
 function nthArg(n = 0) {
     return function (...args) {
         return args.at(toInteger(n));
@@ -1981,7 +1999,35 @@ function throttle(func, throttleMs = 0, options = {}) {
     });
 }
 
+function toString(value) {
+    if (value == null) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.map(toString).join(',');
+    }
+    const result = String(value);
+    if (result === '0' && Object.is(Number(value), -0)) {
+        return '-0';
+    }
+    return result;
+}
+
 function add(value, other) {
+    if (value === undefined && other === undefined) {
+        return 0;
+    }
+    if (value === undefined || other === undefined) {
+        return value ?? other;
+    }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
+    }
+    else {
+        value = toNumber(value);
+        other = toNumber(other);
+    }
     return value + other;
 }
 
@@ -2017,22 +2063,7 @@ function clamp(value, bound1, bound2) {
     return range$1.clamp(value, bound1, bound2);
 }
 
-function toString(value) {
-    if (value == null) {
-        return '';
-    }
-    if (Array.isArray(value)) {
-        return value.map(toString).join(',');
-    }
-    const result = String(value);
-    if (result === '0' && Object.is(Number(value), -0)) {
-        return '-0';
-    }
-    return result;
-}
-
 function divide(value, other) {
-    console.log(value, other);
     if (value === undefined && other === undefined) {
         return 1;
     }
@@ -2099,6 +2130,44 @@ function maxBy(items, iteratee$1) {
     return zipWith.maxBy(Array.from(items), iteratee(iteratee$1));
 }
 
+function sumBy(array, iteratee$1) {
+    if (!array || !array.length) {
+        return 0;
+    }
+    if (iteratee$1 != null) {
+        iteratee$1 = iteratee(iteratee$1);
+    }
+    let result = undefined;
+    for (let i = 0; i < array.length; i++) {
+        const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
+        if (current !== undefined) {
+            if (result === undefined) {
+                result = current;
+            }
+            else {
+                result += current;
+            }
+        }
+    }
+    return result;
+}
+
+function sum(array) {
+    return sumBy(array);
+}
+
+function mean(nums) {
+    const length = nums ? nums.length : 0;
+    return length === 0 ? NaN : sum(nums) / length;
+}
+
+function meanBy(items, iteratee$1) {
+    if (items == null) {
+        return NaN;
+    }
+    return range$1.meanBy(Array.from(items), iteratee(iteratee$1));
+}
+
 function min(items = []) {
     let minElement = items[0];
     let min = undefined;
@@ -2112,6 +2181,13 @@ function min(items = []) {
     return minElement;
 }
 
+function minBy(items, iteratee$1) {
+    if (items == null) {
+        return undefined;
+    }
+    return zipWith.minBy(Array.from(items), iteratee(iteratee$1));
+}
+
 function multiply(value, other) {
     if (value === undefined && other === undefined) {
         return 1;
@@ -2251,33 +2327,21 @@ function round(number, precision = 0) {
 }
 
 function subtract(value, other) {
-    return value - other;
-}
-
-function sumBy(array, iteratee$1) {
-    if (!array || !array.length) {
+    if (value === undefined && other === undefined) {
         return 0;
     }
-    if (iteratee$1 != null) {
-        iteratee$1 = iteratee(iteratee$1);
+    if (value === undefined || other === undefined) {
+        return value ?? other;
     }
-    let result = undefined;
-    for (let i = 0; i < array.length; i++) {
-        const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
-        if (current !== undefined) {
-            if (result === undefined) {
-                result = current;
-            }
-            else {
-                result += current;
-            }
-        }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
     }
-    return result;
-}
-
-function sum(array) {
-    return sumBy(array);
+    else {
+        value = toNumber(value);
+        other = toNumber(other);
+    }
+    return value - other;
 }
 
 function isPrototype(value) {
@@ -2416,6 +2480,19 @@ function fromPairs(pairs) {
     return result;
 }
 
+function functionsIn(object) {
+    if (object == null) {
+        return [];
+    }
+    const result = [];
+    for (const key in object) {
+        if (isWeakSet$1.isFunction(object[key])) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+
 function invertBy(object, iteratee) {
     const result = {};
     if (isWeakSet$1.isNil(object)) {
@@ -3219,7 +3296,7 @@ function invokeImpl(object, path, args) {
         return undefined;
     }
     let lastKey = last(path);
-    let lastValue = lastKey?.valueOf();
+    const lastValue = lastKey?.valueOf();
     if (typeof lastValue === 'number') {
         lastKey = toKey(lastValue);
     }
@@ -3349,7 +3426,6 @@ exports.initial = zipWith.initial;
 exports.isSubset = zipWith.isSubset;
 exports.isSubsetWith = zipWith.isSubsetWith;
 exports.keyBy = zipWith.keyBy;
-exports.minBy = zipWith.minBy;
 exports.partition = zipWith.partition;
 exports.pullAt = zipWith.pullAt;
 exports.sampleSize = zipWith.sampleSize;
@@ -3377,8 +3453,6 @@ exports.partialRight = unary.partialRight;
 exports.retry = unary.retry;
 exports.unary = unary.unary;
 exports.noop = noop.noop;
-exports.mean = range$1.mean;
-exports.meanBy = range$1.meanBy;
 exports.median = range$1.median;
 exports.medianBy = range$1.medianBy;
 exports.randomInt = randomInt.randomInt;
@@ -3391,6 +3465,7 @@ exports.toMerged = toMerged.toMerged;
 exports.isPrimitive = isPlainObject$1.isPrimitive;
 exports.eq = isWeakSet$1.eq;
 exports.isBlob = isWeakSet$1.isBlob;
+exports.isBrowser = isWeakSet$1.isBrowser;
 exports.isEqual = isWeakSet$1.isEqual;
 exports.isFile = isWeakSet$1.isFile;
 exports.isFunction = isWeakSet$1.isFunction;
@@ -3399,6 +3474,7 @@ exports.isJSONArray = isWeakSet$1.isJSONArray;
 exports.isJSONObject = isWeakSet$1.isJSONObject;
 exports.isJSONValue = isWeakSet$1.isJSONValue;
 exports.isLength = isWeakSet$1.isLength;
+exports.isNode = isWeakSet$1.isNode;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isPromise = isWeakSet$1.isPromise;
@@ -3411,7 +3487,8 @@ exports.capitalize = upperFirst$1.capitalize;
 exports.constantCase = upperFirst$1.constantCase;
 exports.pascalCase = upperFirst$1.pascalCase;
 exports.reverseString = upperFirst$1.reverseString;
-exports.invariant = util_index.invariant;
+exports.attemptAsync = invariant.attemptAsync;
+exports.invariant = invariant.invariant;
 exports.add = add;
 exports.after = after;
 exports.ary = ary;
@@ -3471,6 +3548,7 @@ exports.flow = flow;
 exports.flowRight = flowRight;
 exports.forEach = forEach;
 exports.fromPairs = fromPairs;
+exports.functionsIn = functionsIn;
 exports.get = get;
 exports.gt = gt;
 exports.gte = gte;
@@ -3531,11 +3609,14 @@ exports.matches = matches;
 exports.matchesProperty = matchesProperty;
 exports.max = max;
 exports.maxBy = maxBy;
+exports.mean = mean;
+exports.meanBy = meanBy;
 exports.merge = merge;
 exports.mergeWith = mergeWith;
 exports.method = method;
 exports.methodOf = methodOf;
 exports.min = min;
+exports.minBy = minBy;
 exports.multiply = multiply;
 exports.negate = negate;
 exports.now = now;
@@ -3560,6 +3641,7 @@ exports.rangeRight = rangeRight;
 exports.rearg = rearg;
 exports.reduce = reduce;
 exports.reduceRight = reduceRight;
+exports.reject = reject;
 exports.remove = remove;
 exports.repeat = repeat;
 exports.replace = replace;
@@ -3575,6 +3657,7 @@ exports.some = some;
 exports.sortBy = sortBy;
 exports.sortedIndex = sortedIndex;
 exports.sortedIndexBy = sortedIndexBy;
+exports.sortedIndexOf = sortedIndexOf;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;

package/dist/compat/index.mjs

@@ -8,7 +8,6 @@ export { initial } from '../array/initial.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { isSubsetWith } from '../array/isSubsetWith.mjs';
 export { keyBy } from '../array/keyBy.mjs';
-export { minBy } from '../array/minBy.mjs';
 export { partition } from '../array/partition.mjs';
 export { pullAt } from '../array/pullAt.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
@@ -36,8 +35,6 @@ export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
 export { retry } from '../function/retry.mjs';
 export { unary } from '../function/unary.mjs';
-export { mean } from '../math/mean.mjs';
-export { meanBy } from '../math/meanBy.mjs';
 export { median } from '../math/median.mjs';
 export { medianBy } from '../math/medianBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';
@@ -49,6 +46,7 @@ export { isObjectLike } from './predicate/isObjectLike.mjs';
 export { omitBy } from '../object/omitBy.mjs';
 export { toMerged } from '../object/toMerged.mjs';
 export { isBlob } from '../predicate/isBlob.mjs';
+export { isBrowser } from '../predicate/isBrowser.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { eq } from './util/eq.mjs';
 export { isFile } from '../predicate/isFile.mjs';
@@ -56,6 +54,7 @@ export { isFunction } from '../predicate/isFunction.mjs';
 export { isJSON } from '../predicate/isJSON.mjs';
 export { isJSONArray, isJSONObject, isJSONValue } from '../predicate/isJSONValue.mjs';
 export { isLength } from '../predicate/isLength.mjs';
+export { isNode } from '../predicate/isNode.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isPromise } from '../predicate/isPromise.mjs';
@@ -69,6 +68,7 @@ export { constantCase } from '../string/constantCase.mjs';
 import '../string/deburr.mjs';
 export { pascalCase } from '../string/pascalCase.mjs';
 export { reverseString } from '../string/reverseString.mjs';
+export { attemptAsync } from '../util/attemptAsync.mjs';
 export { invariant } from '../util/invariant.mjs';
 export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
@@ -109,6 +109,7 @@ export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
 export { reduce } from './array/reduce.mjs';
 export { reduceRight } from './array/reduceRight.mjs';
+export { reject } from './array/reject.mjs';
 export { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';
@@ -118,6 +119,7 @@ export { some } from './array/some.mjs';
 export { sortBy } from './array/sortBy.mjs';
 export { sortedIndex } from './array/sortedIndex.mjs';
 export { sortedIndexBy } from './array/sortedIndexBy.mjs';
+export { sortedIndexOf } from './array/sortedIndexOf.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -157,7 +159,10 @@ export { floor } from './math/floor.mjs';
 export { inRange } from './math/inRange.mjs';
 export { max } from './math/max.mjs';
 export { maxBy } from './math/maxBy.mjs';
+export { mean } from './math/mean.mjs';
+export { meanBy } from './math/meanBy.mjs';
 export { min } from './math/min.mjs';
+export { minBy } from './math/minBy.mjs';
 export { multiply } from './math/multiply.mjs';
 export { parseInt } from './math/parseInt.mjs';
 export { random } from './math/random.mjs';
@@ -173,6 +178,7 @@ export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
+export { functionsIn } from './object/functionsIn.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
 export { invertBy } from './object/invertBy.mjs';

package/dist/compat/math/add.mjs

@@ -1,4 +1,21 @@
+import { toNumber } from '../util/toNumber.mjs';
+import { toString } from '../util/toString.mjs';
+
 function add(value, other) {
+    if (value === undefined && other === undefined) {
+        return 0;
+    }
+    if (value === undefined || other === undefined) {
+        return value ?? other;
+    }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
+    }
+    else {
+        value = toNumber(value);
+        other = toNumber(other);
+    }
     return value + other;
 }
 

package/dist/compat/math/divide.mjs

@@ -2,7 +2,6 @@ import { toNumber } from '../util/toNumber.mjs';
 import { toString } from '../util/toString.mjs';
 
 function divide(value, other) {
-    console.log(value, other);
     if (value === undefined && other === undefined) {
         return 1;
     }

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

@@ -0,0 +1,16 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the average.
+ * @returns {number} The average of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = mean(numbers);
+ * // result will be 3
+ */
+declare function mean(nums?: readonly number[]): number;
+
+export { mean };

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

@@ -0,0 +1,16 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the average.
+ * @returns {number} The average of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = mean(numbers);
+ * // result will be 3
+ */
+declare function mean(nums?: readonly number[]): number;
+
+export { mean };

package/dist/compat/math/mean.mjs

@@ -0,0 +1,8 @@
+import { sum } from './sum.mjs';
+
+function mean(nums) {
+    const length = nums ? nums.length : 0;
+    return length === 0 ? NaN : sum(nums) / length;
+}
+
+export { mean };

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

@@ -0,0 +1,25 @@
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `iteratee` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>} iteratee
+ * The criteria used to determine the maximum value.
+ *  - If a **function** is provided, it extracts a numeric value from each element.
+ *  - If a **string** is provided, it is treated as a key to extract values from the objects.
+ *  - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair.
+ *  - If an **object** is provided, it matches elements that contain the specified properties.
+ * @returns {number} The average of all the numbers as determined by the `iteratee` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ * meanBy([[2], [3], [1]], 0); // Returns: 2
+ * meanBy([{ a: 2 }, { a: 3 }, { a: 1 }], 'a'); // Returns: 2
+ */
+declare function meanBy<T>(items: ArrayLike<T> | null | undefined, iteratee: ((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>): number;
+
+export { meanBy };

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

@@ -0,0 +1,25 @@
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `iteratee` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>} iteratee
+ * The criteria used to determine the maximum value.
+ *  - If a **function** is provided, it extracts a numeric value from each element.
+ *  - If a **string** is provided, it is treated as a key to extract values from the objects.
+ *  - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair.
+ *  - If an **object** is provided, it matches elements that contain the specified properties.
+ * @returns {number} The average of all the numbers as determined by the `iteratee` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ * meanBy([[2], [3], [1]], 0); // Returns: 2
+ * meanBy([{ a: 2 }, { a: 3 }, { a: 1 }], 'a'); // Returns: 2
+ */
+declare function meanBy<T>(items: ArrayLike<T> | null | undefined, iteratee: ((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>): number;
+
+export { meanBy };

package/dist/compat/math/meanBy.mjs

@@ -0,0 +1,11 @@
+import { meanBy as meanBy$1 } from '../../math/meanBy.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function meanBy(items, iteratee$1) {
+    if (items == null) {
+        return NaN;
+    }
+    return meanBy$1(Array.from(items), iteratee(iteratee$1));
+}
+
+export { meanBy };