es-toolkit 1.7.1 → 1.8.0-dev.159

package/dist/array/index.mjs

@@ -1,13 +1,25 @@
-import "../chunk-XJR5WV2Z.mjs";
+import "../chunk-O5QHO3W7.mjs";
+import {
+  xorWith
+} from "../chunk-QRSJBBFY.mjs";
+import {
+  zip
+} from "../chunk-IDCUZVJL.mjs";
 import {
   zipObject
 } from "../chunk-6GWEY5EL.mjs";
 import {
   zipWith
 } from "../chunk-4KYXHZ4R.mjs";
+import {
+  unionWith
+} from "../chunk-2ZCITDMK.mjs";
 import {
   uniqBy
 } from "../chunk-OXAZEEGP.mjs";
+import {
+  uniqWith
+} from "../chunk-237HGSZS.mjs";
 import {
   unzipWith
 } from "../chunk-IFNXROZR.mjs";
@@ -21,11 +33,13 @@ import {
   xorBy
 } from "../chunk-Q47NGNXT.mjs";
 import {
-  xorWith
-} from "../chunk-QRSJBBFY.mjs";
+  sampleSize
+} from "../chunk-EHSKB6DF.mjs";
+import "../chunk-GIWAOOFY.mjs";
+import "../chunk-SYWMYQYJ.mjs";
 import {
-  zip
-} from "../chunk-IDCUZVJL.mjs";
+  shuffle
+} from "../chunk-G7UQ5PUR.mjs";
 import {
   take
 } from "../chunk-ME352XO7.mjs";
@@ -41,18 +55,15 @@ import {
 import {
   union
 } from "../chunk-R6QA7PLZ.mjs";
+import {
+  uniq
+} from "../chunk-DVK2N4KC.mjs";
 import {
   unionBy
 } from "../chunk-NFS7RWWE.mjs";
 import {
-  unionWith
-} from "../chunk-2ZCITDMK.mjs";
-import {
-  uniqWith
-} from "../chunk-237HGSZS.mjs";
-import {
-  uniq
-} from "../chunk-DVK2N4KC.mjs";
+  intersectionBy
+} from "../chunk-O6UXZR3U.mjs";
 import {
   intersectionWith
 } from "../chunk-XI7KRD2C.mjs";
@@ -65,20 +76,15 @@ import {
 import {
   minBy
 } from "../chunk-IJD7FE2Z.mjs";
+import {
+  orderBy
+} from "../chunk-7B7W36UP.mjs";
 import {
   partition
 } from "../chunk-DN3NOZ3H.mjs";
 import {
   sample
 } from "../chunk-2KNLZB7V.mjs";
-import {
-  sampleSize
-} from "../chunk-EHSKB6DF.mjs";
-import "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import {
-  shuffle
-} from "../chunk-G7UQ5PUR.mjs";
 import {
   dropRightWhile
 } from "../chunk-JE6JKZU3.mjs";
@@ -94,12 +100,12 @@ import {
 import {
   groupBy
 } from "../chunk-E6E4RZLN.mjs";
+import {
+  head
+} from "../chunk-HM2JT2RX.mjs";
 import {
   intersection
 } from "../chunk-FVVSE2F2.mjs";
-import {
-  intersectionBy
-} from "../chunk-O6UXZR3U.mjs";
 import {
   chunk
 } from "../chunk-E6C5EZQA.mjs";
@@ -139,12 +145,14 @@ export {
   fill,
   forEachRight,
   groupBy,
+  head,
   intersection,
   intersectionBy,
   intersectionWith,
   keyBy,
   maxBy,
   minBy,
+  orderBy,
   partition,
   sample,
   sampleSize,

package/dist/array/orderBy.d.mts

@@ -0,0 +1,35 @@
+type Order = 'asc' | 'desc';
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of keys 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,
+ * it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} collection - The array of objects to be sorted.
+ * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.
+ * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+ * @returns {T[]} - The 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 = orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'fred', age: 48 },
+ * //   { user: 'fred', age: 40 },
+ * // ]
+ */
+declare function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[];
+
+export { orderBy };

package/dist/array/orderBy.d.ts

@@ -0,0 +1,35 @@
+type Order = 'asc' | 'desc';
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of keys 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,
+ * it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} collection - The array of objects to be sorted.
+ * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.
+ * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+ * @returns {T[]} - The 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 = orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'fred', age: 48 },
+ * //   { user: 'fred', age: 40 },
+ * // ]
+ */
+declare function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[];
+
+export { orderBy };

package/dist/array/orderBy.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/orderBy.ts
+var orderBy_exports = {};
+__export(orderBy_exports, {
+  orderBy: () => orderBy
+});
+module.exports = __toCommonJS(orderBy_exports);
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orderBy
+});
+//# sourceMappingURL=orderBy.js.map

package/dist/array/orderBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/orderBy.ts"],"sourcesContent":["type Order = 'asc' | 'desc';\n\n/**\n * Sorts an array of objects based on multiple properties and their corresponding order directions.\n *\n * This function takes an array of objects, an array of keys to sort by, and an array of order directions.\n * It returns the sorted array, ordering by each key according to its corresponding direction\n * ('asc' for ascending or 'desc' for descending). If values for a key are equal,\n * it moves to the next key to determine the order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} collection - The array of objects to be sorted.\n * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.\n * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).\n * @returns {T[]} - The sorted array.\n *\n * @example\n * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.\n * const users = [\n *   { user: 'fred', age: 48 },\n *   { user: 'barney', age: 34 },\n *   { user: 'fred', age: 40 },\n *   { user: 'barney', age: 36 },\n * ];\n * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // result will be:\n * // [\n * //   { user: 'barney', age: 36 },\n * //   { user: 'barney', age: 34 },\n * //   { user: 'fred', age: 48 },\n * //   { user: 'fred', age: 40 },\n * // ]\n */\nexport function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[] {\n  const compareValues = (a: T[keyof T], b: T[keyof T], order: Order) => {\n    if (a < b) {\n      return order === 'asc' ? -1 : 1;\n    }\n    if (a > b) {\n      return order === 'asc' ? 1 : -1;\n    }\n    return 0;\n  };\n\n  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);\n\n  return collection.slice().sort((a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const order = effectiveOrders[i];\n      const result = compareValues(a[key], b[key], order);\n      if (result !== 0) {\n        return result;\n      }\n    }\n    return 0;\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCO,SAAS,QAAW,YAAiB,MAAsB,QAAsB;AACtF,QAAM,gBAAgB,CAAC,GAAe,GAAe,UAAiB;AACpE,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,KAAK;AAAA,IAChC;AACA,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,IAAI;AAAA,IAC/B;AACA,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,KAAK,IAAI,CAAC,GAAG,UAAU,OAAO,KAAK,KAAK,OAAO,OAAO,SAAS,CAAC,CAAC;AAEzF,SAAO,WAAW,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,YAAM,SAAS,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,KAAK;AAClD,UAAI,WAAW,GAAG;AAChB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/array/orderBy.mjs

@@ -0,0 +1,8 @@
+import {
+  orderBy
+} from "../chunk-7B7W36UP.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  orderBy
+};
+//# sourceMappingURL=orderBy.mjs.map

package/dist/chunk-7B7W36UP.mjs

@@ -0,0 +1,29 @@
+// src/array/orderBy.ts
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+
+export {
+  orderBy
+};
+//# sourceMappingURL=chunk-7B7W36UP.mjs.map

package/dist/chunk-7B7W36UP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/orderBy.ts"],"sourcesContent":["type Order = 'asc' | 'desc';\n\n/**\n * Sorts an array of objects based on multiple properties and their corresponding order directions.\n *\n * This function takes an array of objects, an array of keys to sort by, and an array of order directions.\n * It returns the sorted array, ordering by each key according to its corresponding direction\n * ('asc' for ascending or 'desc' for descending). If values for a key are equal,\n * it moves to the next key to determine the order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} collection - The array of objects to be sorted.\n * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.\n * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).\n * @returns {T[]} - The sorted array.\n *\n * @example\n * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.\n * const users = [\n *   { user: 'fred', age: 48 },\n *   { user: 'barney', age: 34 },\n *   { user: 'fred', age: 40 },\n *   { user: 'barney', age: 36 },\n * ];\n * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // result will be:\n * // [\n * //   { user: 'barney', age: 36 },\n * //   { user: 'barney', age: 34 },\n * //   { user: 'fred', age: 48 },\n * //   { user: 'fred', age: 40 },\n * // ]\n */\nexport function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[] {\n  const compareValues = (a: T[keyof T], b: T[keyof T], order: Order) => {\n    if (a < b) {\n      return order === 'asc' ? -1 : 1;\n    }\n    if (a > b) {\n      return order === 'asc' ? 1 : -1;\n    }\n    return 0;\n  };\n\n  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);\n\n  return collection.slice().sort((a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const order = effectiveOrders[i];\n      const result = compareValues(a[key], b[key], order);\n      if (result !== 0) {\n        return result;\n      }\n    }\n    return 0;\n  });\n}\n"],"mappings":";AAiCO,SAAS,QAAW,YAAiB,MAAsB,QAAsB;AACtF,QAAM,gBAAgB,CAAC,GAAe,GAAe,UAAiB;AACpE,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,KAAK;AAAA,IAChC;AACA,QAAI,IAAI,GAAG;AACT,aAAO,UAAU,QAAQ,IAAI;AAAA,IAC/B;AACA,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,KAAK,IAAI,CAAC,GAAG,UAAU,OAAO,KAAK,KAAK,OAAO,OAAO,SAAS,CAAC,CAAC;AAEzF,SAAO,WAAW,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,YAAM,SAAS,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,KAAK;AAClD,UAAI,WAAW,GAAG;AAChB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/chunk-BH6HLGBA.mjs

@@ -0,0 +1,16 @@
+// src/math/inRange.ts
+function inRange(value, minimum, maximum) {
+  if (maximum == null) {
+    maximum = minimum;
+    minimum = 0;
+  }
+  if (minimum >= maximum) {
+    throw new Error("The maximum value must be greater than the minimum value.");
+  }
+  return minimum <= value && value < maximum;
+}
+
+export {
+  inRange
+};
+//# sourceMappingURL=chunk-BH6HLGBA.mjs.map

package/dist/chunk-BH6HLGBA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/inRange.ts"],"sourcesContent":["export function inRange(value: number, maximum: number): boolean;\nexport function inRange(value: number, minimum: number, maximum: number): boolean;\n/**\n * Checks if the value is within a specified range.\n *\n * @param {number} value The value to check.\n * @param {number} minimum The lower bound of the range (inclusive).\n * @param {number} maximum The upper bound of the range (exclusive).\n * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.\n * @throws {Error} Throws an error if the `minimum` is greater or equal than the `maximum`.\n *\n * @example\n * const result1 = inRange(3, 5); // result1 will be true.\n * const result2 = inRange(1, 2, 5); // result2 will be false.\n * const result3 = inRange(1, 5, 2); // If the minimum is greater or equal than the maximum, an error is thrown.\n */\nexport function inRange(value: number, minimum: number, maximum?: number): boolean {\n  if (maximum == null) {\n    maximum = minimum;\n    minimum = 0;\n  }\n\n  if (minimum >= maximum) {\n    throw new Error('The maximum value must be greater than the minimum value.');\n  }\n\n  return minimum <= value && value < maximum;\n}\n"],"mappings":";AAgBO,SAAS,QAAQ,OAAe,SAAiB,SAA2B;AACjF,MAAI,WAAW,MAAM;AACnB,cAAU;AACV,cAAU;AAAA,EACZ;AAEA,MAAI,WAAW,SAAS;AACtB,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AAEA,SAAO,WAAW,SAAS,QAAQ;AACrC;","names":[]}

package/dist/chunk-FLTT2MGF.mjs

@@ -0,0 +1,14 @@
+// src/object/invert.ts
+function invert(obj) {
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    result[value] = key;
+  }
+  return result;
+}
+
+export {
+  invert
+};
+//# sourceMappingURL=chunk-FLTT2MGF.mjs.map

package/dist/chunk-FLTT2MGF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object/invert.ts"],"sourcesContent":["/**\n * Inverts the keys and values of an object. The keys of the input object become the values of the output object and vice versa.\n *\n * This function takes an object and creates a new object by inverting its keys and values. If the input object has duplicate values,\n * the key of the last occurrence will be used as the value for the new key in the output object. It effectively creates a reverse mapping\n * of the input object's key-value pairs.\n *\n * @template K - Type of the keys in the input object (string, number, symbol)\n * @template V - Type of the values in the input object (string, number, symbol)\n * @param {Record<K, V>} obj - The input object whose keys and values are to be inverted\n * @returns {{ [key in V]: K }} - A new object with keys and values inverted\n *\n * @example\n * invert({ a: 1, b: 2, c: 3 }); // { 1: 'a', 2: 'b', 3: 'c' }\n * invert({ 1: 'a', 2: 'b', 3: 'c' }); // { a: '1', b: '2', c: '3' }\n * invert({ a: 1, 2: 'b', c: 3, 4: 'd' }); // { 1: 'a', b: '2', 3: 'c', d: '4' }\n * invert({ a: Symbol('sym1'), b: Symbol('sym2') }); // { [Symbol('sym1')]: 'a', [Symbol('sym2')]: 'b' }\n */\n\ntype PropertyKey = string | number | symbol;\n\nexport function invert<K extends PropertyKey, V extends PropertyKey>(obj: Record<K, V>): { [key in V]: K } {\n  const result = {} as { [key in V]: K };\n\n  for (const key in obj) {\n    const value = obj[key as K] as V;\n    result[value] = key;\n  }\n\n  return result;\n}\n"],"mappings":";AAqBO,SAAS,OAAqD,KAAsC;AACzG,QAAM,SAAS,CAAC;AAEhB,aAAW,OAAO,KAAK;AACrB,UAAM,QAAQ,IAAI,GAAQ;AAC1B,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-HM2JT2RX.mjs

@@ -0,0 +1,9 @@
+// src/array/head.ts
+function head(arr) {
+  return arr[0];
+}
+
+export {
+  head
+};
+//# sourceMappingURL=chunk-HM2JT2RX.mjs.map

package/dist/chunk-HM2JT2RX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/head.ts"],"sourcesContent":["/**\n * Returns the first element of an array.\n *\n * This function takes an array and returns the first element of the array.\n * If the array is empty, the function returns `undefined`.\n *\n * @param {T[]} arr - The array from which to get the first element.\n * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.\n *\n * @example\n * const arr = [1, 2, 3];\n * const firstElement = head(arr);\n * // firstElement will be 1\n *\n * const emptyArr: number[] = [];\n * const noElement = head(emptyArr);\n * // noElement will be undefined\n */\nexport function head<T>(arr: readonly [T, ...T[]]): T;\nexport function head<T>(arr: readonly T[]): T | undefined;\nexport function head<T>(arr: readonly T[]): T | undefined {\n  return arr[0];\n}\n"],"mappings":";AAoBO,SAAS,KAAQ,KAAkC;AACxD,SAAO,IAAI,CAAC;AACd;","names":[]}

package/dist/chunk-O5QHO3W7.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-O5QHO3W7.mjs.map

package/dist/chunk-PMHULJNL.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-PMHULJNL.mjs.map

package/dist/chunk-PMHULJNL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-TLVQSNOE.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-TLVQSNOE.mjs.map

package/dist/chunk-TLVQSNOE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.mts

@@ -17,6 +17,7 @@ export { intersectionWith } from './array/intersectionWith.mjs';
 export { keyBy } from './array/keyBy.mjs';
 export { maxBy } from './array/maxBy.mjs';
 export { minBy } from './array/minBy.mjs';
+export { orderBy } from './array/orderBy.mjs';
 export { partition } from './array/partition.mjs';
 export { sample } from './array/sample.mjs';
 export { sampleSize } from './array/sampleSize.mjs';
@@ -39,12 +40,14 @@ export { zip } from './array/zip.mjs';
 export { zipObject } from './array/zipObject.mjs';
 export { zipWith } from './array/zipWith.mjs';
 export { without } from './array/without.mjs';
+export { head } from './array/head.mjs';
 export { AbortError } from './error/AbortError.mjs';
 export { debounce } from './function/debounce.mjs';
 export { noop } from './function/noop.mjs';
 export { once } from './function/once.mjs';
 export { throttle } from './function/throttle.mjs';
 export { clamp } from './math/clamp.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';
@@ -56,6 +59,7 @@ export { omit } from './object/omit.mjs';
 export { omitBy } from './object/omitBy.mjs';
 export { pick } from './object/pick.mjs';
 export { pickBy } from './object/pickBy.mjs';
+export { invert } from './object/invert.mjs';
 export { isNil } from './predicate/isNil.mjs';
 export { isNotNil } from './predicate/isNotNil.mjs';
 export { isNull } from './predicate/isNull.mjs';

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export { intersectionWith } from './array/intersectionWith.js';
 export { keyBy } from './array/keyBy.js';
 export { maxBy } from './array/maxBy.js';
 export { minBy } from './array/minBy.js';
+export { orderBy } from './array/orderBy.js';
 export { partition } from './array/partition.js';
 export { sample } from './array/sample.js';
 export { sampleSize } from './array/sampleSize.js';
@@ -39,12 +40,14 @@ export { zip } from './array/zip.js';
 export { zipObject } from './array/zipObject.js';
 export { zipWith } from './array/zipWith.js';
 export { without } from './array/without.js';
+export { head } from './array/head.js';
 export { AbortError } from './error/AbortError.js';
 export { debounce } from './function/debounce.js';
 export { noop } from './function/noop.js';
 export { once } from './function/once.js';
 export { throttle } from './function/throttle.js';
 export { clamp } from './math/clamp.js';
+export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';
 export { meanBy } from './math/meanBy.js';
 export { random } from './math/random.js';
@@ -56,6 +59,7 @@ export { omit } from './object/omit.js';
 export { omitBy } from './object/omitBy.js';
 export { pick } from './object/pick.js';
 export { pickBy } from './object/pickBy.js';
+export { invert } from './object/invert.js';
 export { isNil } from './predicate/isNil.js';
 export { isNotNil } from './predicate/isNotNil.js';
 export { isNull } from './predicate/isNull.js';

package/dist/index.js

@@ -51,9 +51,12 @@ __export(src_exports, {
   fill: () => fill,
   forEachRight: () => forEachRight,
   groupBy: () => groupBy,
+  head: () => head,
+  inRange: () => inRange,
   intersection: () => intersection,
   intersectionBy: () => intersectionBy,
   intersectionWith: () => intersectionWith,
+  invert: () => invert,
   isNil: () => isNil,
   isNotNil: () => isNotNil,
   isNull: () => isNull,
@@ -67,6 +70,7 @@ __export(src_exports, {
   omit: () => omit,
   omitBy: () => omitBy,
   once: () => once,
+  orderBy: () => orderBy,
   partition: () => partition,
   pick: () => pick,
   pickBy: () => pickBy,
@@ -278,6 +282,31 @@ function minBy(items, getValue) {
   return minElement;
 }
 
+// src/array/orderBy.ts
+function orderBy(collection, keys, orders) {
+  const compareValues = (a, b, order) => {
+    if (a < b) {
+      return order === "asc" ? -1 : 1;
+    }
+    if (a > b) {
+      return order === "asc" ? 1 : -1;
+    }
+    return 0;
+  };
+  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+  return collection.slice().sort((a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const order = effectiveOrders[i];
+      const result = compareValues(a[key], b[key], order);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  });
+}
+
 // src/array/partition.ts
 function partition(arr, isInTruthy) {
   const truthy = [];
@@ -504,6 +533,11 @@ function without(array, ...values) {
   return array.filter((item) => !valuesSet.has(item));
 }
 
+// src/array/head.ts
+function head(arr) {
+  return arr[0];
+}
+
 // src/error/AbortError.ts
 var AbortError = class extends Error {
   constructor(message = "The operation was aborted") {
@@ -580,6 +614,18 @@ function clamp(value, bound1, bound2) {
   return Math.min(Math.max(value, bound1), bound2);
 }
 
+// src/math/inRange.ts
+function inRange(value, minimum, maximum) {
+  if (maximum == null) {
+    maximum = minimum;
+    minimum = 0;
+  }
+  if (minimum >= maximum) {
+    throw new Error("The maximum value must be greater than the minimum value.");
+  }
+  return minimum <= value && value < maximum;
+}
+
 // src/math/sum.ts
 function sum(nums) {
   let result = 0;
@@ -671,6 +717,16 @@ function pickBy(obj, shouldPick) {
   return result;
 }
 
+// src/object/invert.ts
+function invert(obj) {
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    result[value] = key;
+  }
+  return result;
+}
+
 // src/predicate/isNil.ts
 function isNil(x) {
   return x === null || x === void 0;
@@ -727,9 +783,12 @@ function delay(ms, { signal } = {}) {
   fill,
   forEachRight,
   groupBy,
+  head,
+  inRange,
   intersection,
   intersectionBy,
   intersectionWith,
+  invert,
   isNil,
   isNotNil,
   isNull,
@@ -743,6 +802,7 @@ function delay(ms, { signal } = {}) {
   omit,
   omitBy,
   once,
+  orderBy,
   partition,
   pick,
   pickBy,