es-toolkit 1.17.0-dev.526 → 1.17.0-dev.528

package/dist/compat/_internal/compareValues.mjs

@@ -1,9 +1,34 @@
-const compareValues = (a, b, order) => {
-    if ((a != null && b == null) || a < b) {
-        return order === 'desc' ? 1 : -1;
+function getPriority(a) {
+    if (typeof a === 'symbol') {
+        return 1;
+    }
+    if (a === null) {
+        return 2;
+    }
+    if (a === undefined) {
+        return 3;
     }
-    if ((a == null && b != null) || a > b) {
-        return order === 'desc' ? -1 : 1;
+    if (a !== a) {
+        return 4;
+    }
+    return 0;
+}
+const compareValues = (a, b, order) => {
+    if (a !== b) {
+        if (typeof a === 'string' && typeof b === 'string') {
+            return order === 'desc' ? b.localeCompare(a) : a.localeCompare(b);
+        }
+        const aPriority = getPriority(a);
+        const bPriority = getPriority(b);
+        if (aPriority === bPriority && aPriority === 0) {
+            if (a < b) {
+                return order === 'desc' ? 1 : -1;
+            }
+            if (a > b) {
+                return order === 'desc' ? -1 : 1;
+            }
+        }
+        return order === 'desc' ? bPriority - aPriority : aPriority - bPriority;
     }
     return 0;
 };

package/dist/compat/array/orderBy.d.mts

@@ -1,14 +1,14 @@
+type Criterion<T> = ((item: T) => unknown) | PropertyKey | PropertyKey[] | null | undefined;
 /**
  * Sorts an array of objects based on multiple properties and their corresponding order directions.
  *
  * This function takes an array of objects, an array of criteria to sort by, and an array of order directions.
- * It returns the sorted array, ordering by each key according to its corresponding direction
- * ('asc' for ascending or 'desc' for descending). If values for a key are equal,string
- * it moves to the next key to determine the order.
+ * It returns the sorted array, ordering by each key according to its corresponding direction ('asc' for ascending or 'desc' for descending).
+ * If values for a key are equal, it moves to the next key to determine the order.
  *
  * @template T - The type of elements in the array.
  * @param { T[] | object | null | undefined} collection - The array of objects to be sorted.
- * @param {((item: T) => unknown) | PropertyKey | Array<((item: T) => unknown) | PropertyKey | PropertyKey[]>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @param {Criterion<T> | Array<Criterion<T>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
  * @param {unknown | unknown[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
  * @returns {T[]} - The sorted array.
  *
@@ -29,6 +29,6 @@
  * //   { user: 'fred', age: 40 },
  * // ]
  */
-declare function orderBy<T>(collection: T[] | object | null | undefined, criteria?: ((item: T) => unknown) | PropertyKey | Array<((item: T) => unknown) | PropertyKey | PropertyKey[]>, orders?: unknown | unknown[]): T[];
+declare function orderBy<T>(collection: T[] | object | number | null | undefined, criteria?: Criterion<T> | Array<Criterion<T>>, orders?: unknown | unknown[]): T[];
 
-export { orderBy };
+export { type Criterion, orderBy };

package/dist/compat/array/orderBy.d.ts

@@ -1,14 +1,14 @@
+type Criterion<T> = ((item: T) => unknown) | PropertyKey | PropertyKey[] | null | undefined;
 /**
  * Sorts an array of objects based on multiple properties and their corresponding order directions.
  *
  * This function takes an array of objects, an array of criteria to sort by, and an array of order directions.
- * It returns the sorted array, ordering by each key according to its corresponding direction
- * ('asc' for ascending or 'desc' for descending). If values for a key are equal,string
- * it moves to the next key to determine the order.
+ * It returns the sorted array, ordering by each key according to its corresponding direction ('asc' for ascending or 'desc' for descending).
+ * If values for a key are equal, it moves to the next key to determine the order.
  *
  * @template T - The type of elements in the array.
  * @param { T[] | object | null | undefined} collection - The array of objects to be sorted.
- * @param {((item: T) => unknown) | PropertyKey | Array<((item: T) => unknown) | PropertyKey | PropertyKey[]>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @param {Criterion<T> | Array<Criterion<T>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
  * @param {unknown | unknown[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
  * @returns {T[]} - The sorted array.
  *
@@ -29,6 +29,6 @@
  * //   { user: 'fred', age: 40 },
  * // ]
  */
-declare function orderBy<T>(collection: T[] | object | null | undefined, criteria?: ((item: T) => unknown) | PropertyKey | Array<((item: T) => unknown) | PropertyKey | PropertyKey[]>, orders?: unknown | unknown[]): T[];
+declare function orderBy<T>(collection: T[] | object | number | null | undefined, criteria?: Criterion<T> | Array<Criterion<T>>, orders?: unknown | unknown[]): T[];
 
-export { orderBy };
+export { type Criterion, orderBy };

package/dist/compat/array/orderBy.mjs

@@ -3,64 +3,72 @@ import { isKey } from '../_internal/isKey.mjs';
 import { toPath } from '../_internal/toPath.mjs';
 
 function orderBy(collection, criteria, orders) {
-    if (collection == null) {
+    if (collection == null || typeof collection === 'number') {
         return [];
     }
-    if (!Array.isArray(collection) && typeof collection === 'object') {
+    if (typeof collection === 'object' && !Array.isArray(collection)) {
         collection = Object.values(collection);
     }
     if (!Array.isArray(criteria)) {
-        criteria = criteria == null ? [] : [criteria];
+        criteria = criteria == null ? [null] : [criteria];
     }
     if (!Array.isArray(orders)) {
         orders = orders == null ? [] : [orders];
     }
+    orders = orders.map(order => String(order));
     const getValueByNestedPath = (object, path) => {
         let target = object;
-        for (let i = 0; i < path.length && target != null; i++) {
+        for (let i = 0; i < path.length && target != null; ++i) {
             target = target[path[i]];
         }
         return target;
     };
     const getValueByCriterion = (criterion, object) => {
-        if (object == null) {
+        if (object == null || criterion == null) {
             return object;
         }
+        if (typeof criterion === 'object' && 'key' in criterion) {
+            if (Object.hasOwn(object, criterion.key)) {
+                return object[criterion.key];
+            }
+            return getValueByNestedPath(object, criterion.path);
+        }
         if (typeof criterion === 'function') {
             return criterion(object);
         }
         if (Array.isArray(criterion)) {
             return getValueByNestedPath(object, criterion);
         }
-        if (typeof criterion !== 'object') {
+        if (typeof object === 'object') {
             return object[criterion];
         }
-        if (Object.hasOwn(object, criterion.key)) {
-            return object[criterion.key];
-        }
-        return getValueByNestedPath(object, criterion.path);
+        return object;
     };
     const preparedCriteria = criteria.map(criterion => {
         if (Array.isArray(criterion) && criterion.length === 1) {
             criterion = criterion[0];
         }
-        if (typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
+        if (criterion == null || typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
             return criterion;
         }
         return { key: criterion, path: toPath(criterion) };
     });
-    return collection.slice().sort((a, b) => {
-        for (let i = 0; i < criteria.length; i++) {
-            const order = String(orders[i]);
-            const valueA = getValueByCriterion(preparedCriteria[i], a);
-            const valueB = getValueByCriterion(preparedCriteria[i], b);
-            const comparedResult = compareValues(valueA, valueB, order);
+    const preparedCollection = collection.map(item => ({
+        original: item,
+        criteria: preparedCriteria.map(criterion => getValueByCriterion(criterion, item)),
+    }));
+    return preparedCollection
+        .slice()
+        .sort((a, b) => {
+        for (let i = 0; i < preparedCriteria.length; i++) {
+            const comparedResult = compareValues(a.criteria[i], b.criteria[i], orders[i]);
             if (comparedResult !== 0) {
                 return comparedResult;
             }
         }
         return 0;
-    });
+    })
+        .map(item => item.original);
 }
 
 export { orderBy };

package/dist/compat/array/sortBy.d.mts

@@ -0,0 +1,34 @@
+import { Criterion } from './orderBy.mjs';
+
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of criteria to sort by.
+ * It returns the ascending sorted array, ordering by each key.
+ * If values for a key are equal, it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param { T[] | object | null | undefined} collection - The array of objects to be sorted.
+ * @param {Criterion<T> | Array<Criterion<T>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @returns {T[]} - The ascending sorted array.
+ *
+ * @example
+ * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+ * const users = [
+ *   { user: 'fred', age: 48 },
+ *   { user: 'barney', age: 34 },
+ *   { user: 'fred', age: 40 },
+ *   { user: 'barney', age: 36 },
+ * ];
+ * const result = sortBy(users, ['user', (item) => item.age])
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'fred', age: 40 },
+ * //   { user: 'fred', age: 48 },
+ * // ]
+ */
+declare function sortBy<T>(collection: T[] | object | number | null | undefined, criteria?: Criterion<T> | Array<Criterion<T>>): T[];
+
+export { sortBy };

package/dist/compat/array/sortBy.d.ts

@@ -0,0 +1,34 @@
+import { Criterion } from './orderBy.js';
+
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of criteria to sort by.
+ * It returns the ascending sorted array, ordering by each key.
+ * If values for a key are equal, it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param { T[] | object | null | undefined} collection - The array of objects to be sorted.
+ * @param {Criterion<T> | Array<Criterion<T>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @returns {T[]} - The ascending sorted array.
+ *
+ * @example
+ * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+ * const users = [
+ *   { user: 'fred', age: 48 },
+ *   { user: 'barney', age: 34 },
+ *   { user: 'fred', age: 40 },
+ *   { user: 'barney', age: 36 },
+ * ];
+ * const result = sortBy(users, ['user', (item) => item.age])
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'fred', age: 40 },
+ * //   { user: 'fred', age: 48 },
+ * // ]
+ */
+declare function sortBy<T>(collection: T[] | object | number | null | undefined, criteria?: Criterion<T> | Array<Criterion<T>>): T[];
+
+export { sortBy };

package/dist/compat/array/sortBy.mjs

@@ -0,0 +1,7 @@
+import { orderBy } from './orderBy.mjs';
+
+function sortBy(collection, criteria) {
+    return orderBy(collection, criteria, ['asc']);
+}
+
+export { sortBy };

package/dist/compat/index.d.mts

@@ -20,7 +20,6 @@ export { maxBy } from '../array/maxBy.mjs';
 export { minBy } from '../array/minBy.mjs';
 export { partition } from '../array/partition.mjs';
 export { pullAt } from '../array/pullAt.mjs';
-export { sortBy } from '../array/sortBy.mjs';
 export { sample } from '../array/sample.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
@@ -115,6 +114,7 @@ export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
 export { orderBy } from './array/orderBy.mjs';
+export { sortBy } from './array/sortBy.mjs';
 export { size } from './array/size.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { indexOf } from './array/indexOf.mjs';

package/dist/compat/index.d.ts

@@ -20,7 +20,6 @@ export { maxBy } from '../array/maxBy.js';
 export { minBy } from '../array/minBy.js';
 export { partition } from '../array/partition.js';
 export { pullAt } from '../array/pullAt.js';
-export { sortBy } from '../array/sortBy.js';
 export { sample } from '../array/sample.js';
 export { sampleSize } from '../array/sampleSize.js';
 export { shuffle } from '../array/shuffle.js';
@@ -115,6 +114,7 @@ export { flatten } from './array/flatten.js';
 export { flattenDeep } from './array/flattenDeep.js';
 export { flattenDepth } from './array/flattenDepth.js';
 export { orderBy } from './array/orderBy.js';
+export { sortBy } from './array/sortBy.js';
 export { size } from './array/size.js';
 export { zipObjectDeep } from './array/zipObjectDeep.js';
 export { indexOf } from './array/indexOf.js';

package/dist/compat/index.js

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const array_index = require('../array/index.js');
+const initial = require('../_chunk/initial-crEecP.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
 const rest$1 = require('../_chunk/rest-Bzm2XK.js');
 const math_index = require('../math/index.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-BGwYW5.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-BRIIbG.js');
-const isTypedArray$1 = require('../_chunk/isTypedArray-BBEkFl.js');
+const toMerged = require('../_chunk/toMerged-DN1PPP.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-CogETi.js');
+const isTypedArray$1 = require('../_chunk/isTypedArray-Dsrnb1.js');
 const string_index = require('../string/index.js');
 
 function chunk(arr, size = 1) {
@@ -17,17 +17,17 @@ function chunk(arr, size = 1) {
     if (size === 0) {
         return [];
     }
-    return array_index.chunk(arr, size);
+    return initial.chunk(arr, size);
 }
 
 function concat(...values) {
-    return array_index.flatten(values);
+    return initial.flatten(values);
 }
 
 function difference(arr, ...values) {
     const arr1 = arr;
-    const arr2 = array_index.flatten(values);
-    return array_index.difference(arr1, arr2);
+    const arr2 = initial.flatten(values);
+    return initial.difference(arr1, arr2);
 }
 
 function fill(array, value, start = 0, end = array.length) {
@@ -39,7 +39,7 @@ function fill(array, value, start = 0, end = array.length) {
     if (!end) {
         end = 0;
     }
-    return array_index.fill(array, value, start, end);
+    return initial.fill(array, value, start, end);
 }
 
 const IS_PLAIN = /^\w*$/;
@@ -426,12 +426,37 @@ function flattenDepth(value, depth = 1) {
     return flatten(value, depth);
 }
 
-const compareValues = (a, b, order) => {
-    if ((a != null && b == null) || a < b) {
-        return order === 'desc' ? 1 : -1;
+function getPriority(a) {
+    if (typeof a === 'symbol') {
+        return 1;
+    }
+    if (a === null) {
+        return 2;
+    }
+    if (a === undefined) {
+        return 3;
     }
-    if ((a == null && b != null) || a > b) {
-        return order === 'desc' ? -1 : 1;
+    if (a !== a) {
+        return 4;
+    }
+    return 0;
+}
+const compareValues = (a, b, order) => {
+    if (a !== b) {
+        if (typeof a === 'string' && typeof b === 'string') {
+            return order === 'desc' ? b.localeCompare(a) : a.localeCompare(b);
+        }
+        const aPriority = getPriority(a);
+        const bPriority = getPriority(b);
+        if (aPriority === bPriority && aPriority === 0) {
+            if (a < b) {
+                return order === 'desc' ? 1 : -1;
+            }
+            if (a > b) {
+                return order === 'desc' ? -1 : 1;
+            }
+        }
+        return order === 'desc' ? bPriority - aPriority : aPriority - bPriority;
     }
     return 0;
 };
@@ -450,64 +475,76 @@ function isKey(value, object) {
 }
 
 function orderBy(collection, criteria, orders) {
-    if (collection == null) {
+    if (collection == null || typeof collection === 'number') {
         return [];
     }
-    if (!Array.isArray(collection) && typeof collection === 'object') {
+    if (typeof collection === 'object' && !Array.isArray(collection)) {
         collection = Object.values(collection);
     }
     if (!Array.isArray(criteria)) {
-        criteria = criteria == null ? [] : [criteria];
+        criteria = criteria == null ? [null] : [criteria];
     }
     if (!Array.isArray(orders)) {
         orders = orders == null ? [] : [orders];
     }
+    orders = orders.map(order => String(order));
     const getValueByNestedPath = (object, path) => {
         let target = object;
-        for (let i = 0; i < path.length && target != null; i++) {
+        for (let i = 0; i < path.length && target != null; ++i) {
             target = target[path[i]];
         }
         return target;
     };
     const getValueByCriterion = (criterion, object) => {
-        if (object == null) {
+        if (object == null || criterion == null) {
             return object;
         }
+        if (typeof criterion === 'object' && 'key' in criterion) {
+            if (Object.hasOwn(object, criterion.key)) {
+                return object[criterion.key];
+            }
+            return getValueByNestedPath(object, criterion.path);
+        }
         if (typeof criterion === 'function') {
             return criterion(object);
         }
         if (Array.isArray(criterion)) {
             return getValueByNestedPath(object, criterion);
         }
-        if (typeof criterion !== 'object') {
+        if (typeof object === 'object') {
             return object[criterion];
         }
-        if (Object.hasOwn(object, criterion.key)) {
-            return object[criterion.key];
-        }
-        return getValueByNestedPath(object, criterion.path);
+        return object;
     };
     const preparedCriteria = criteria.map(criterion => {
         if (Array.isArray(criterion) && criterion.length === 1) {
             criterion = criterion[0];
         }
-        if (typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
+        if (criterion == null || typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
             return criterion;
         }
         return { key: criterion, path: toPath(criterion) };
     });
-    return collection.slice().sort((a, b) => {
-        for (let i = 0; i < criteria.length; i++) {
-            const order = String(orders[i]);
-            const valueA = getValueByCriterion(preparedCriteria[i], a);
-            const valueB = getValueByCriterion(preparedCriteria[i], b);
-            const comparedResult = compareValues(valueA, valueB, order);
+    const preparedCollection = collection.map(item => ({
+        original: item,
+        criteria: preparedCriteria.map(criterion => getValueByCriterion(criterion, item)),
+    }));
+    return preparedCollection
+        .slice()
+        .sort((a, b) => {
+        for (let i = 0; i < preparedCriteria.length; i++) {
+            const comparedResult = compareValues(a.criteria[i], b.criteria[i], orders[i]);
             if (comparedResult !== 0) {
                 return comparedResult;
             }
         }
         return 0;
-    });
+    })
+        .map(item => item.original);
+}
+
+function sortBy(collection, criteria) {
+    return orderBy(collection, criteria, ['asc']);
 }
 
 function size(target) {
@@ -538,7 +575,7 @@ function set(obj, path, value) {
 
 function zipObjectDeep(keys, values) {
     const result = {};
-    const zipped = array_index.zip(keys, values);
+    const zipped = initial.zip(keys, values);
     for (let i = 0; i < zipped.length; i++) {
         const [key, value] = zipped[i];
         if (key != null) {
@@ -844,58 +881,57 @@ function min(items = []) {
     return minElement;
 }
 
-exports.at = array_index.at;
-exports.compact = array_index.compact;
-exports.countBy = array_index.countBy;
-exports.differenceBy = array_index.differenceBy;
-exports.differenceWith = array_index.differenceWith;
-exports.drop = array_index.drop;
-exports.dropRight = array_index.dropRight;
-exports.dropRightWhile = array_index.dropRightWhile;
-exports.dropWhile = array_index.dropWhile;
-exports.first = array_index.head;
-exports.flatMap = array_index.flatMap;
-exports.flatMapDeep = array_index.flatMapDeep;
-exports.forEachRight = array_index.forEachRight;
-exports.groupBy = array_index.groupBy;
-exports.head = array_index.head;
-exports.initial = array_index.initial;
-exports.intersection = array_index.intersection;
-exports.intersectionBy = array_index.intersectionBy;
-exports.intersectionWith = array_index.intersectionWith;
-exports.isSubset = array_index.isSubset;
-exports.join = array_index.join;
-exports.keyBy = array_index.keyBy;
-exports.last = array_index.last;
-exports.maxBy = array_index.maxBy;
-exports.minBy = array_index.minBy;
-exports.partition = array_index.partition;
-exports.pullAt = array_index.pullAt;
-exports.sample = array_index.sample;
-exports.sampleSize = array_index.sampleSize;
-exports.shuffle = array_index.shuffle;
-exports.sortBy = array_index.sortBy;
-exports.tail = array_index.tail;
-exports.take = array_index.take;
-exports.takeRight = array_index.takeRight;
-exports.takeRightWhile = array_index.takeRightWhile;
-exports.takeWhile = array_index.takeWhile;
-exports.toFilled = array_index.toFilled;
-exports.union = array_index.union;
-exports.unionBy = array_index.unionBy;
-exports.unionWith = array_index.unionWith;
-exports.uniq = array_index.uniq;
-exports.uniqBy = array_index.uniqBy;
-exports.uniqWith = array_index.uniqWith;
-exports.unzip = array_index.unzip;
-exports.unzipWith = array_index.unzipWith;
-exports.without = array_index.without;
-exports.xor = array_index.xor;
-exports.xorBy = array_index.xorBy;
-exports.xorWith = array_index.xorWith;
-exports.zip = array_index.zip;
-exports.zipObject = array_index.zipObject;
-exports.zipWith = array_index.zipWith;
+exports.at = initial.at;
+exports.compact = initial.compact;
+exports.countBy = initial.countBy;
+exports.differenceBy = initial.differenceBy;
+exports.differenceWith = initial.differenceWith;
+exports.drop = initial.drop;
+exports.dropRight = initial.dropRight;
+exports.dropRightWhile = initial.dropRightWhile;
+exports.dropWhile = initial.dropWhile;
+exports.first = initial.head;
+exports.flatMap = initial.flatMap;
+exports.flatMapDeep = initial.flatMapDeep;
+exports.forEachRight = initial.forEachRight;
+exports.groupBy = initial.groupBy;
+exports.head = initial.head;
+exports.initial = initial.initial;
+exports.intersection = initial.intersection;
+exports.intersectionBy = initial.intersectionBy;
+exports.intersectionWith = initial.intersectionWith;
+exports.isSubset = initial.isSubset;
+exports.join = initial.join;
+exports.keyBy = initial.keyBy;
+exports.last = initial.last;
+exports.maxBy = initial.maxBy;
+exports.minBy = initial.minBy;
+exports.partition = initial.partition;
+exports.pullAt = initial.pullAt;
+exports.sample = initial.sample;
+exports.sampleSize = initial.sampleSize;
+exports.shuffle = initial.shuffle;
+exports.tail = initial.tail;
+exports.take = initial.take;
+exports.takeRight = initial.takeRight;
+exports.takeRightWhile = initial.takeRightWhile;
+exports.takeWhile = initial.takeWhile;
+exports.toFilled = initial.toFilled;
+exports.union = initial.union;
+exports.unionBy = initial.unionBy;
+exports.unionWith = initial.unionWith;
+exports.uniq = initial.uniq;
+exports.uniqBy = initial.uniqBy;
+exports.uniqWith = initial.uniqWith;
+exports.unzip = initial.unzip;
+exports.unzipWith = initial.unzipWith;
+exports.without = initial.without;
+exports.xor = initial.xor;
+exports.xorBy = initial.xorBy;
+exports.xorWith = initial.xorWith;
+exports.zip = initial.zip;
+exports.zipObject = initial.zipObject;
+exports.zipWith = initial.zipWith;
 exports.AbortError = promise_index.AbortError;
 exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
@@ -996,6 +1032,7 @@ exports.repeat = repeat;
 exports.rest = rest;
 exports.set = set;
 exports.size = size;
+exports.sortBy = sortBy;
 exports.spread = spread;
 exports.startsWith = startsWith;
 exports.zipObjectDeep = zipObjectDeep;

package/dist/compat/index.mjs

@@ -20,7 +20,6 @@ export { maxBy } from '../array/maxBy.mjs';
 export { minBy } from '../array/minBy.mjs';
 export { partition } from '../array/partition.mjs';
 export { pullAt } from '../array/pullAt.mjs';
-export { sortBy } from '../array/sortBy.mjs';
 export { sample } from '../array/sample.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
@@ -116,6 +115,7 @@ export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
 export { orderBy } from './array/orderBy.mjs';
+export { sortBy } from './array/sortBy.mjs';
 export { size } from './array/size.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { indexOf } from './array/indexOf.mjs';