es-toolkit 1.17.0 → 1.18.0-dev.573

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/_internal/normalizeForCase.mjs

@@ -0,0 +1,9 @@
+function normalizeForCase(str) {
+    if (typeof str === 'object') {
+        str = str.toString();
+    }
+    str = str.replace(/['\u2019]/g, '');
+    return str;
+}
+
+export { normalizeForCase };

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

@@ -0,0 +1,29 @@
+/**
+ * Casts value as an array if it's not one.
+ *
+ * @template T The type of elements in the array.
+ * @param {T | readonly T[]} value The value to be cast to an array.
+ * @returns {T[]} An array containing the input value if it wasn't an array, or the original array if it was.
+ *
+ * @example
+ * const arr1 = castArray(1);
+ * // Returns: [1]
+ *
+ * const arr2 = castArray([1]);
+ * // Returns: [1]
+ *
+ * const arr3 = castArray({'a': 1});
+ * // Returns: [{'a': 1}]
+ *
+ * const arr4 =  castArray(null);
+ * // Returns: [null]
+ *
+ * const arr5 = castArray(undefined);
+ * // Returns: [undefined]
+ *
+ * const arr6 = castArray();
+ * // Returns: []
+ */
+declare function castArray<T>(value?: T | readonly T[]): T[];
+
+export { castArray };

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

@@ -0,0 +1,29 @@
+/**
+ * Casts value as an array if it's not one.
+ *
+ * @template T The type of elements in the array.
+ * @param {T | readonly T[]} value The value to be cast to an array.
+ * @returns {T[]} An array containing the input value if it wasn't an array, or the original array if it was.
+ *
+ * @example
+ * const arr1 = castArray(1);
+ * // Returns: [1]
+ *
+ * const arr2 = castArray([1]);
+ * // Returns: [1]
+ *
+ * const arr3 = castArray({'a': 1});
+ * // Returns: [{'a': 1}]
+ *
+ * const arr4 =  castArray(null);
+ * // Returns: [null]
+ *
+ * const arr5 = castArray(undefined);
+ * // Returns: [undefined]
+ *
+ * const arr6 = castArray();
+ * // Returns: []
+ */
+declare function castArray<T>(value?: T | readonly T[]): T[];
+
+export { castArray };

package/dist/compat/array/castArray.mjs

@@ -0,0 +1,8 @@
+function castArray(value) {
+    if (arguments.length === 0) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+
+export { castArray };

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

@@ -1,3 +1,22 @@
+/**
+ * Computes the difference between an array and multiple arrays.
+ *
+ * @template T
+ * @param {T[]} arr - The primary array from which to derive the difference. This is the main array
+ * from which elements will be compared and filtered.
+ * @param {...T[]} values - Multiple arrays containing elements to be excluded from the primary array.
+ * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array.
+ * If a match is found, that element will be excluded from the result.
+ * @returns {T[]} A new array containing the elements that are present in the primary array but not
+ * in the flattened array.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [2, 4];
+ * const array3 = [5, 6];
+ * const result = difference(array1, array2, array3);
+ * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result.
+ */
 declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
 
 export { difference };

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

@@ -1,3 +1,22 @@
+/**
+ * Computes the difference between an array and multiple arrays.
+ *
+ * @template T
+ * @param {T[]} arr - The primary array from which to derive the difference. This is the main array
+ * from which elements will be compared and filtered.
+ * @param {...T[]} values - Multiple arrays containing elements to be excluded from the primary array.
+ * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array.
+ * If a match is found, that element will be excluded from the result.
+ * @returns {T[]} A new array containing the elements that are present in the primary array but not
+ * in the flattened array.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [2, 4];
+ * const array3 = [5, 6];
+ * const result = difference(array1, array2, array3);
+ * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result.
+ */
 declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
 
 export { difference };

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

@@ -1,3 +1,58 @@
+/**
+ * Fills the whole array with a specified value.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value?: T): T[];
+/**
+ * Fills elements of an array with a specified value from the start position to the end.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {S} [start=0] - The start position. Defaults to 0.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
 /**
  * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
  *
@@ -26,8 +81,6 @@
  * const result = fill(array, '*', -2, -1);
  * // => [1, '*', 3]
  */
-declare function fill<T>(array: unknown[], value?: T): T[];
-declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
 declare function fill<T, U, S, V>(array: Array<T | U>, value: U, start: S, end: V): Array<T | U>;
 
 export { fill };

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

@@ -1,3 +1,58 @@
+/**
+ * Fills the whole array with a specified value.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value?: T): T[];
+/**
+ * Fills elements of an array with a specified value from the start position to the end.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {S} [start=0] - The start position. Defaults to 0.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
 /**
  * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
  *
@@ -26,8 +81,6 @@
  * const result = fill(array, '*', -2, -1);
  * // => [1, '*', 3]
  */
-declare function fill<T>(array: unknown[], value?: T): T[];
-declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
 declare function fill<T, U, S, V>(array: Array<T | U>, value: U, start: S, end: V): Array<T | U>;
 
 export { fill };

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

@@ -0,0 +1,66 @@
+/**
+ * Iterates through an array in reverse order and returns the index of the first item that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = findLastIndex(items, (item) => item > 3)
+ * console.log(result); // 4
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, { name: 'Bob' });
+ * console.log(result); // 1
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatch: Partial<T>, fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, ['name', 'Alice']);
+ * console.log(result); // 0
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown], fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, 'name');
+ * console.log(result); // 1
+ */
+declare function findLastIndex<T>(arr: readonly T[], propertyToCheck: string, fromIndex?: number): number;
+
+export { findLastIndex };

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

@@ -0,0 +1,66 @@
+/**
+ * Iterates through an array in reverse order and returns the index of the first item that matches the given predicate function.
+ *
+ * @template T
+ * @param {T[]} arr - The array to search through.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - A function that takes an item, its index, and the array, and returns a truthy value if the item matches the criteria.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that matches the predicate, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a predicate function
+ * const items = [1, 2, 3, 4, 5];
+ * const result = findLastIndex(items, (item) => item > 3)
+ * console.log(result); // 4
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatch: (item: T, index: number, arr: readonly T[]) => unknown, fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that matches the given partial object.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that matches the partial object, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a partial object
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, { name: 'Bob' });
+ * console.log(result); // 1
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatch: Partial<T>, fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that matches a property with a specific value.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {[keyof T, unknown]} doesMatchProperty - An array where the first element is the property key and the second element is the value to match.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that has the specified property value, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property-value pair
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, ['name', 'Alice']);
+ * console.log(result); // 0
+ */
+declare function findLastIndex<T>(arr: readonly T[], doesMatchProperty: [keyof T, unknown], fromIndex?: number): number;
+/**
+ * Finds the index of the first item in an array that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {readonly T[]} arr - The array to search through.
+ * @param {string} propertyToCheck - The property name to check.
+ * @param {number} [fromIndex=arr.length - 1] - The index to start the search from, defaults to the last index of the array.
+ * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found.
+ *
+ * @example
+ * // Using a property name
+ * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * const result = findLastIndex(items, 'name');
+ * console.log(result); // 1
+ */
+declare function findLastIndex<T>(arr: readonly T[], propertyToCheck: string, fromIndex?: number): number;
+
+export { findLastIndex };

package/dist/compat/array/findLastIndex.mjs

@@ -0,0 +1,33 @@
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function findLastIndex(source, doesMatch, fromIndex = source.length - 1) {
+    if (fromIndex < 0) {
+        fromIndex = Math.max(source.length + fromIndex, 0);
+    }
+    else {
+        fromIndex = Math.min(fromIndex, source.length - 1);
+    }
+    source = source.slice(0, fromIndex + 1);
+    switch (typeof doesMatch) {
+        case 'function': {
+            return source.findLastIndex(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return source.findLastIndex(matchesProperty(key, value));
+            }
+            else {
+                return source.findLastIndex(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return source.findLastIndex(property(doesMatch));
+        }
+    }
+}
+
+export { findLastIndex };

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

@@ -0,0 +1,16 @@
+/**
+ * Joins elements of an array into a string.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to join.
+ * @param {string} separator - The separator used to join the elements, default is common separator `,`.
+ * @returns {string} - Returns a string containing all elements of the array joined by the specified separator.
+ *
+ * @example
+ * const arr = ["a", "b", "c"];
+ * const result = join(arr, "~");
+ * console.log(result); // Output: "a~b~c"
+ */
+declare function join<T>(array: readonly T[], separator?: string): string;
+
+export { join };

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

@@ -0,0 +1,16 @@
+/**
+ * Joins elements of an array into a string.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to join.
+ * @param {string} separator - The separator used to join the elements, default is common separator `,`.
+ * @returns {string} - Returns a string containing all elements of the array joined by the specified separator.
+ *
+ * @example
+ * const arr = ["a", "b", "c"];
+ * const result = join(arr, "~");
+ * console.log(result); // Output: "a~b~c"
+ */
+declare function join<T>(array: readonly T[], separator?: string): string;
+
+export { join };

package/dist/compat/array/join.mjs

@@ -0,0 +1,5 @@
+function join(array, separator = ',') {
+    return array.join(separator);
+}
+
+export { join };

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 };