es-toolkit 1.0.3 → 1.0.4-dev.41

package/{esm/array/sample.mjs → dist/array/sample.d.mts}

@@ -1,6 +1,6 @@
 /**
  * Returns a random element from an array.
- * 
+ *
  * This function takes an array and returns a single element selected randomly from the array.
  *
  * @param {T[]} arr - The array to sample from.
@@ -11,9 +11,6 @@
  * const randomElement = sample(array);
  * // randomElement will be one of the elements from the array, selected randomly.
  */
-function sample(arr) {
-  var randomIndex = Math.floor(Math.random() * arr.length);
-  return arr[randomIndex];
-}
+declare function sample<T>(arr: T[]): T;
 
 export { sample };

package/dist/array/sample.d.ts

@@ -11,4 +11,6 @@
  * const randomElement = sample(array);
  * // randomElement will be one of the elements from the array, selected randomly.
  */
-export declare function sample<T>(arr: T[]): T;
+declare function sample<T>(arr: T[]): T;
+
+export { sample };

package/dist/array/sample.js

@@ -0,0 +1,34 @@
+"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/sample.ts
+var sample_exports = {};
+__export(sample_exports, {
+  sample: () => sample
+});
+module.exports = __toCommonJS(sample_exports);
+function sample(arr) {
+  const randomIndex = Math.floor(Math.random() * arr.length);
+  return arr[randomIndex];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sample
+});
+//# sourceMappingURL=sample.js.map

package/dist/array/sample.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/sample.ts"],"sourcesContent":["/**\n * Returns a random element from an array.\n *\n * This function takes an array and returns a single element selected randomly from the array.\n *\n * @param {T[]} arr - The array to sample from.\n * @returns {T} A random element from the array.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const randomElement = sample(array);\n * // randomElement will be one of the elements from the array, selected randomly.\n */\nexport function sample<T>(arr: T[]): T {\n  const randomIndex = Math.floor(Math.random() * arr.length);\n  return arr[randomIndex];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,OAAU,KAAa;AACrC,QAAM,cAAc,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM;AACzD,SAAO,IAAI,WAAW;AACxB;","names":[]}

package/dist/array/sample.mjs

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

package/dist/array/sample.mjs.map

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

package/{esm/array/shuffle.mjs → dist/array/shuffle.d.mts}

@@ -1,6 +1,6 @@
 /**
  * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
- * 
+ *
  * This function takes an array and returns a new array with its elements shuffled in a random order.
  *
  * @param {T[]} arr - The array to shuffle.
@@ -11,17 +11,6 @@
  * const shuffledArray = shuffle(array);
  * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
  */
-function shuffle(arr) {
-  /**
-   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
-   */
-  for (var i = arr.length - 1; i >= 1; i--) {
-    var j = Math.floor(Math.random() * (i + 1));
-    var _ref = [arr[j], arr[i]];
-    arr[i] = _ref[0];
-    arr[j] = _ref[1];
-  }
-  return arr;
-}
+declare function shuffle<T>(arr: T[]): T[];
 
 export { shuffle };

package/dist/array/shuffle.d.ts

@@ -11,4 +11,6 @@
  * const shuffledArray = shuffle(array);
  * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
  */
-export declare function shuffle<T>(arr: T[]): T[];
+declare function shuffle<T>(arr: T[]): T[];
+
+export { shuffle };

package/dist/array/shuffle.js

@@ -0,0 +1,37 @@
+"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/shuffle.ts
+var shuffle_exports = {};
+__export(shuffle_exports, {
+  shuffle: () => shuffle
+});
+module.exports = __toCommonJS(shuffle_exports);
+function shuffle(arr) {
+  for (let i = arr.length - 1; i >= 1; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shuffle
+});
+//# sourceMappingURL=shuffle.js.map

package/dist/array/shuffle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/shuffle.ts"],"sourcesContent":["/**\n * Randomizes the order of elements in an array using the Fisher-Yates algorithm.\n *\n * This function takes an array and returns a new array with its elements shuffled in a random order.\n *\n * @param {T[]} arr - The array to shuffle.\n * @returns {T[]} A new array with its elements shuffled in random order.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const shuffledArray = shuffle(array);\n * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]\n */\nexport function shuffle<T>(arr: T[]): T[] {\n  /**\n   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n   */\n  for (let i = arr.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n\n    [arr[i], arr[j]] = [arr[j], arr[i]];\n  }\n\n  return arr;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,QAAW,KAAe;AAIxC,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAE5C,KAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":[]}

package/dist/array/shuffle.mjs

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

package/dist/array/shuffle.mjs.map

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

package/{esm/array/take.mjs → dist/array/take.d.mts}

@@ -3,25 +3,23 @@
  * If `count` is greater than the length of `arr`, the entire array is returned.
  *
  * @template T - Type of elements in the input array.
- * 
+ *
  * @param {T[]} arr - The array to take elements from.
  * @param {number} count - The number of elements to take.
  * @returns {T[]} A new array containing the first `count` elements from `arr`.
- * 
+ *
  * @example
  * // Returns [1, 2, 3]
  * take([1, 2, 3, 4, 5], 3);
- * 
+ *
  * @example
  * // Returns ['a', 'b']
  * take(['a', 'b', 'c'], 2);
- * 
+ *
  * @example
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-function take(arr, count) {
-  return arr.slice(0, count);
-}
+declare function take<T>(arr: T[], count: number): T[];
 
 export { take };

package/dist/array/take.d.ts

@@ -20,4 +20,6 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-export declare function take<T>(arr: T[], count: number): T[];
+declare function take<T>(arr: T[], count: number): T[];
+
+export { take };

package/dist/array/take.js

@@ -0,0 +1,33 @@
+"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/take.ts
+var take_exports = {};
+__export(take_exports, {
+  take: () => take
+});
+module.exports = __toCommonJS(take_exports);
+function take(arr, count) {
+  return arr.slice(0, count);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  take
+});
+//# sourceMappingURL=take.js.map

package/dist/array/take.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/take.ts"],"sourcesContent":["/**\n * Returns a new array containing the first `count` elements from the input array `arr`.\n * If `count` is greater than the length of `arr`, the entire array is returned.\n *\n * @template T - Type of elements in the input array.\n *\n * @param {T[]} arr - The array to take elements from.\n * @param {number} count - The number of elements to take.\n * @returns {T[]} A new array containing the first `count` elements from `arr`.\n *\n * @example\n * // Returns [1, 2, 3]\n * take([1, 2, 3, 4, 5], 3);\n *\n * @example\n * // Returns ['a', 'b']\n * take(['a', 'b', 'c'], 2);\n *\n * @example\n * // Returns [1, 2, 3]\n * take([1, 2, 3], 5);\n */\nexport function take<T>(arr: T[], count: number) {\n  return arr.slice(0, count);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,SAAS,KAAQ,KAAU,OAAe;AAC/C,SAAO,IAAI,MAAM,GAAG,KAAK;AAC3B;","names":[]}

package/dist/array/take.mjs

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

package/dist/array/take.mjs.map

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

package/{esm/array/takeRight.mjs → dist/array/takeRight.d.mts}

@@ -1,28 +1,23 @@
 /**
  * Returns a new array containing the last `count` elements from the input array `arr`.
  * If `count` is greater than the length of `arr`, the entire array is returned.
- * 
+ *
  * @param {T[]} arr - The array to take elements from.
  * @param {number} count - The number of elements to take.
  * @returns {T[]} A new array containing the last `count` elements from `arr`.
- * 
+ *
  * @example
  * // Returns [4, 5]
  * takeRight([1, 2, 3, 4, 5], 2);
- * 
+ *
  * @example
  * // Returns ['b', 'c']
  * takeRight(['a', 'b', 'c'], 2);
- * 
+ *
  * @example
  * // Returns [1, 2, 3]
  * takeRight([1, 2, 3], 5);
  */
-function takeRight(arr, count) {
-  if (count === 0) {
-    return [];
-  }
-  return arr.slice(-count);
-}
+declare function takeRight<T>(arr: T[], count: number): T[];
 
 export { takeRight };

package/dist/array/takeRight.d.ts

@@ -18,4 +18,6 @@
  * // Returns [1, 2, 3]
  * takeRight([1, 2, 3], 5);
  */
-export declare function takeRight<T>(arr: T[], count: number): T[];
+declare function takeRight<T>(arr: T[], count: number): T[];
+
+export { takeRight };

package/dist/array/takeRight.js

@@ -0,0 +1,36 @@
+"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/takeRight.ts
+var takeRight_exports = {};
+__export(takeRight_exports, {
+  takeRight: () => takeRight
+});
+module.exports = __toCommonJS(takeRight_exports);
+function takeRight(arr, count) {
+  if (count === 0) {
+    return [];
+  }
+  return arr.slice(-count);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  takeRight
+});
+//# sourceMappingURL=takeRight.js.map

package/dist/array/takeRight.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/takeRight.ts"],"sourcesContent":["/**\n * Returns a new array containing the last `count` elements from the input array `arr`.\n * If `count` is greater than the length of `arr`, the entire array is returned.\n *\n * @param {T[]} arr - The array to take elements from.\n * @param {number} count - The number of elements to take.\n * @returns {T[]} A new array containing the last `count` elements from `arr`.\n *\n * @example\n * // Returns [4, 5]\n * takeRight([1, 2, 3, 4, 5], 2);\n *\n * @example\n * // Returns ['b', 'c']\n * takeRight(['a', 'b', 'c'], 2);\n *\n * @example\n * // Returns [1, 2, 3]\n * takeRight([1, 2, 3], 5);\n */\nexport function takeRight<T>(arr: T[], count: number): T[] {\n  if (count === 0) {\n    return [];\n  }\n\n  return arr.slice(-count);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,UAAa,KAAU,OAAoB;AACzD,MAAI,UAAU,GAAG;AACf,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,CAAC,KAAK;AACzB;","names":[]}

package/dist/array/takeRight.mjs

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

package/dist/array/takeRight.mjs.map

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

package/{esm/array/takeRightWhile.mjs → dist/array/takeRightWhile.d.mts}

@@ -1,27 +1,20 @@
 /**
  * Takes elements from the end of the array while the predicate function returns `true`.
- * 
+ *
  * @template T - Type of elements in the input array.
- * 
+ *
  * @param {T[]} arr - The array to take elements from.
  * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.
  * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
- * 
+ *
  * @example
  * // Returns [3, 2, 1]
  * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
- * 
+ *
  * @example
  * // Returns []
  * takeRightWhile([1, 2, 3], n => n > 3);
  */
-function takeRightWhile(arr, shouldContinueTaking) {
-  for (var i = arr.length - 1; i >= 0; i--) {
-    if (!shouldContinueTaking(arr[i])) {
-      return arr.slice(i + 1);
-    }
-  }
-  return arr.slice();
-}
+declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
 
 export { takeRightWhile };

package/dist/array/takeRightWhile.d.ts

@@ -15,4 +15,6 @@
  * // Returns []
  * takeRightWhile([1, 2, 3], n => n > 3);
  */
-export declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
+declare function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
+
+export { takeRightWhile };

package/dist/array/takeRightWhile.js

@@ -0,0 +1,38 @@
+"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/takeRightWhile.ts
+var takeRightWhile_exports = {};
+__export(takeRightWhile_exports, {
+  takeRightWhile: () => takeRightWhile
+});
+module.exports = __toCommonJS(takeRightWhile_exports);
+function takeRightWhile(arr, shouldContinueTaking) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!shouldContinueTaking(arr[i])) {
+      return arr.slice(i + 1);
+    }
+  }
+  return arr.slice();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  takeRightWhile
+});
+//# sourceMappingURL=takeRightWhile.js.map

package/dist/array/takeRightWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/takeRightWhile.ts"],"sourcesContent":["/**\n * Takes elements from the end of the array while the predicate function returns `true`.\n *\n * @template T - Type of elements in the input array.\n *\n * @param {T[]} arr - The array to take elements from.\n * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.\n * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.\n *\n * @example\n * // Returns [3, 2, 1]\n * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);\n *\n * @example\n * // Returns []\n * takeRightWhile([1, 2, 3], n => n > 3);\n */\nexport function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[] {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (!shouldContinueTaking(arr[i])) {\n      return arr.slice(i + 1);\n    }\n  }\n\n  return arr.slice();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,eAAkB,KAAU,sBAAiD;AAC3F,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,QAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,GAAG;AACjC,aAAO,IAAI,MAAM,IAAI,CAAC;AAAA,IACxB;AAAA,EACF;AAEA,SAAO,IAAI,MAAM;AACnB;","names":[]}

package/dist/array/takeRightWhile.mjs

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

package/dist/array/takeRightWhile.mjs.map

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

package/{esm/array/takeWhile.mjs → dist/array/takeWhile.d.mts}

@@ -1,5 +1,3 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Returns a new array containing the leading elements of the provided array
  * that satisfy the provided predicate function. It stops taking elements as soon
@@ -18,24 +16,6 @@ import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virt
  * // Returns []
  * takeWhile([1, 2, 3, 4], x => x > 3);
  */
-function takeWhile(arr, shouldContinueTaking) {
-  var result = [];
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      if (!shouldContinueTaking(item)) {
-        break;
-      }
-      result.push(item);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return result;
-}
+declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
 
 export { takeWhile };

package/dist/array/takeWhile.d.ts

@@ -16,4 +16,6 @@
  * // Returns []
  * takeWhile([1, 2, 3, 4], x => x > 3);
  */
-export declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
+declare function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
+
+export { takeWhile };

package/dist/array/takeWhile.js

@@ -0,0 +1,40 @@
+"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/takeWhile.ts
+var takeWhile_exports = {};
+__export(takeWhile_exports, {
+  takeWhile: () => takeWhile
+});
+module.exports = __toCommonJS(takeWhile_exports);
+function takeWhile(arr, shouldContinueTaking) {
+  const result = [];
+  for (const item of arr) {
+    if (!shouldContinueTaking(item)) {
+      break;
+    }
+    result.push(item);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  takeWhile
+});
+//# sourceMappingURL=takeWhile.js.map

package/dist/array/takeWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/takeWhile.ts"],"sourcesContent":["/**\n * Returns a new array containing the leading elements of the provided array\n * that satisfy the provided predicate function. It stops taking elements as soon\n * as an element does not satisfy the predicate.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to process.\n * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.\n * @returns {T[]} A new array containing the leading elements that satisfy the predicate.\n *\n * @example\n * // Returns [1, 2]\n * takeWhile([1, 2, 3, 4], x => x < 3);\n *\n * @example\n * // Returns []\n * takeWhile([1, 2, 3, 4], x => x > 3);\n */\nexport function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    if (!shouldContinueTaking(item)) {\n      break;\n    }\n\n    result.push(item);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAAS,UAAa,KAAU,sBAAoD;AACzF,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,QAAI,CAAC,qBAAqB,IAAI,GAAG;AAC/B;AAAA,IACF;AAEA,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/array/takeWhile.mjs

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

package/dist/array/takeWhile.mjs.map

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

package/{esm/array/union.mjs → dist/array/union.d.mts}

@@ -1,9 +1,7 @@
-import { uniq } from './uniq.mjs';
-
 /**
  * Creates an array of unique values from all given arrays.
- * 
- * This function takes two arrays, merges them into a single array, and returns a new array 
+ *
+ * This function takes two arrays, merges them into a single array, and returns a new array
  * containing only the unique values from the merged array.
  *
  * @param {T[]} arr1 - The first array to merge and filter for unique values.
@@ -16,8 +14,6 @@ import { uniq } from './uniq.mjs';
  * const result = union(array1, array2);
  * // result will be [1, 2, 3, 4, 5]
  */
-function union(arr1, arr2) {
-  return uniq(arr1.concat(arr2));
-}
+declare function union<T>(arr1: T[], arr2: T[]): T[];
 
 export { union };

package/dist/array/union.d.ts

@@ -14,4 +14,6 @@
  * const result = union(array1, array2);
  * // result will be [1, 2, 3, 4, 5]
  */
-export declare function union<T>(arr1: T[], arr2: T[]): T[];
+declare function union<T>(arr1: T[], arr2: T[]): T[];
+
+export { union };

package/dist/array/union.js

@@ -0,0 +1,47 @@
+"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/union.ts
+var union_exports = {};
+__export(union_exports, {
+  union: () => union
+});
+module.exports = __toCommonJS(union_exports);
+
+// src/array/uniq.ts
+function uniq(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (result.includes(item)) {
+      continue;
+    }
+    result.push(item);
+  }
+  return result;
+}
+
+// src/array/union.ts
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  union
+});
+//# sourceMappingURL=union.js.map

package/dist/array/union.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/union.ts","../../src/array/uniq.ts"],"sourcesContent":["import { uniq } from './uniq';\n\n/**\n * Creates an array of unique values from all given arrays.\n *\n * This function takes two arrays, merges them into a single array, and returns a new array\n * containing only the unique values from the merged array.\n *\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @returns {T[]} A new array of unique values.\n *\n * @example\n * const array1 = [1, 2, 3];\n * const array2 = [3, 4, 5];\n * const result = union(array1, array2);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function union<T>(arr1: T[], arr2: T[]): T[] {\n  return uniq(arr1.concat(arr2));\n}\n","/**\n * Creates a duplicate-free version of an array.\n *\n * This function takes an array and returns a new array containing only the unique values\n * from the original array, preserving the order of first occurrence.\n *\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n *  * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: T[]): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    if (result.includes(item)) {\n      continue;\n    }\n\n    result.push(item);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACcO,SAAS,KAAQ,KAAe;AACrC,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,QAAI,OAAO,SAAS,IAAI,GAAG;AACzB;AAAA,IACF;AAEA,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;;;ADRO,SAAS,MAAS,MAAW,MAAgB;AAClD,SAAO,KAAK,KAAK,OAAO,IAAI,CAAC;AAC/B;","names":[]}