es-toolkit 1.0.3 → 1.0.4-dev.41

package/dist/array/dropRightWhile.d.ts

@@ -15,4 +15,6 @@
  * const result = dropRightWhile(array, x => x > 3);
  * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
  */
-export declare function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+declare function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+
+export { dropRightWhile };

package/dist/array/dropRightWhile.js

@@ -0,0 +1,43 @@
+"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/dropRightWhile.ts
+var dropRightWhile_exports = {};
+__export(dropRightWhile_exports, {
+  dropRightWhile: () => dropRightWhile
+});
+module.exports = __toCommonJS(dropRightWhile_exports);
+
+// src/array/dropWhile.ts
+function dropWhile(arr, canContinueDropping) {
+  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
+  return arr.slice(dropEndIndex);
+}
+
+// src/array/dropRightWhile.ts
+function dropRightWhile(arr, canContinueDropping) {
+  const reversed = arr.slice().reverse();
+  const dropped = dropWhile(reversed, canContinueDropping);
+  return dropped.slice().reverse();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dropRightWhile
+});
+//# sourceMappingURL=dropRightWhile.js.map

package/dist/array/dropRightWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/dropRightWhile.ts","../../src/array/dropWhile.ts"],"sourcesContent":["import { dropWhile } from './dropWhile';\n\n/**\n * Removes elements from the end of an array until the predicate returns false.\n *\n * This function iterates over an array from the end and drops elements until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element from the end,\n * and dropping continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropRightWhile(array, x => x > 3);\n * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.\n */\nexport function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean) {\n  const reversed = arr.slice().reverse();\n  const dropped = dropWhile(reversed, canContinueDropping);\n  return dropped.slice().reverse();\n}\n","/**\n * Removes elements from the beginning of an array until the predicate returns false.\n *\n * This function iterates over an array and drops elements from the start until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element, and dropping\n * continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropWhile(array, x => x < 3);\n * // result will be [3, 4, 5] since elements less than 3 are dropped.\n */\nexport function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[] {\n  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));\n  return arr.slice(dropEndIndex);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,SAAS,UAAa,KAAU,qBAAgD;AACrF,QAAM,eAAe,IAAI,UAAU,UAAQ,CAAC,oBAAoB,IAAI,CAAC;AACrE,SAAO,IAAI,MAAM,YAAY;AAC/B;;;ADDO,SAAS,eAAkB,KAAU,qBAA2C;AACrF,QAAM,WAAW,IAAI,MAAM,EAAE,QAAQ;AACrC,QAAM,UAAU,UAAU,UAAU,mBAAmB;AACvD,SAAO,QAAQ,MAAM,EAAE,QAAQ;AACjC;","names":[]}

package/dist/array/dropRightWhile.mjs

@@ -0,0 +1,9 @@
+import {
+  dropRightWhile
+} from "../chunk-6LDIBBWQ.mjs";
+import "../chunk-3PFYAKOD.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  dropRightWhile
+};
+//# sourceMappingURL=dropRightWhile.mjs.map

package/dist/array/dropRightWhile.mjs.map

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

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

@@ -1,12 +1,12 @@
 /**
  * Removes elements from the beginning of an array until the predicate returns false.
- * 
- * This function iterates over an array and drops elements from the start until the provided 
+ *
+ * This function iterates over an array and drops elements from the start until the provided
  * predicate function returns false. It then returns a new array with the remaining elements.
  *
  * @param {T[]} arr - The array from which to drop elements.
- * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines 
- * whether to continue dropping elements. The function is called with each element, and dropping 
+ * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element, and dropping
  * continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -15,11 +15,6 @@
  * const result = dropWhile(array, x => x < 3);
  * // result will be [3, 4, 5] since elements less than 3 are dropped.
  */
-function dropWhile(arr, canContinueDropping) {
-  var dropEndIndex = arr.findIndex(function (item) {
-    return !canContinueDropping(item);
-  });
-  return arr.slice(dropEndIndex);
-}
+declare function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
 
 export { dropWhile };

package/dist/array/dropWhile.d.ts

@@ -15,4 +15,6 @@
  * const result = dropWhile(array, x => x < 3);
  * // result will be [3, 4, 5] since elements less than 3 are dropped.
  */
-export declare function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+declare function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+
+export { dropWhile };

package/dist/array/dropWhile.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/dropWhile.ts
+var dropWhile_exports = {};
+__export(dropWhile_exports, {
+  dropWhile: () => dropWhile
+});
+module.exports = __toCommonJS(dropWhile_exports);
+function dropWhile(arr, canContinueDropping) {
+  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
+  return arr.slice(dropEndIndex);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dropWhile
+});
+//# sourceMappingURL=dropWhile.js.map

package/dist/array/dropWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/dropWhile.ts"],"sourcesContent":["/**\n * Removes elements from the beginning of an array until the predicate returns false.\n *\n * This function iterates over an array and drops elements from the start until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element, and dropping\n * continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropWhile(array, x => x < 3);\n * // result will be [3, 4, 5] since elements less than 3 are dropped.\n */\nexport function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[] {\n  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));\n  return arr.slice(dropEndIndex);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,UAAa,KAAU,qBAAgD;AACrF,QAAM,eAAe,IAAI,UAAU,UAAQ,CAAC,oBAAoB,IAAI,CAAC;AACrE,SAAO,IAAI,MAAM,YAAY;AAC/B;","names":[]}

package/dist/array/dropWhile.mjs

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

package/dist/array/dropWhile.mjs.map

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

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

@@ -1,15 +1,13 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Groups the elements of an array based on a provided key-generating function.
- * 
- * This function takes an array and a function that generates a key from each element. It returns 
- * an object where the keys are the generated keys and the values are arrays of elements that share 
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
  * the same key.
  *
  * @param {T[]} arr - The array to group.
  * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
- * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that 
+ * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that
  * share that key.
  *
  * @example
@@ -30,25 +28,6 @@ import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virt
  * //   ]
  * // }
  */
-function groupBy(arr, getKeyFromItem) {
-  var result = {};
-  var _iterator = _createForOfIteratorHelper(arr),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var item = _step.value;
-      var key = getKeyFromItem(item);
-      if (result[key] == null) {
-        result[key] = [];
-      }
-      result[key].push(item);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return result;
-}
+declare function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
 
 export { groupBy };

package/dist/array/groupBy.d.ts

@@ -28,4 +28,6 @@
  * //   ]
  * // }
  */
-export declare function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+declare function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+
+export { groupBy };

package/dist/array/groupBy.js

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

package/dist/array/groupBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/groupBy.ts"],"sourcesContent":["/**\n * Groups the elements of an array based on a provided key-generating function.\n *\n * This function takes an array and a function that generates a key from each element. It returns\n * an object where the keys are the generated keys and the values are arrays of elements that share\n * the same key.\n *\n * @param {T[]} arr - The array to group.\n * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.\n * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that\n * share that key.\n *\n * @example\n * const array = [\n *   { category: 'fruit', name: 'apple' },\n *   { category: 'fruit', name: 'banana' },\n *   { category: 'vegetable', name: 'carrot' }\n * ];\n * const result = groupBy(array, item => item.category);\n * // result will be:\n * // {\n * //   fruit: [\n * //     { category: 'fruit', name: 'apple' },\n * //     { category: 'fruit', name: 'banana' }\n * //   ],\n * //   vegetable: [\n * //     { category: 'vegetable', name: 'carrot' }\n * //   ]\n * // }\n */\nexport function groupBy<T, K extends string>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n\n  for (const item of arr) {\n    const key = getKeyFromItem(item);\n\n    if (result[key] == null) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8BO,SAAS,QAA6B,KAAU,gBAAgD;AACrG,QAAM,SAAS,CAAC;AAEhB,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,eAAe,IAAI;AAE/B,QAAI,OAAO,GAAG,KAAK,MAAM;AACvB,aAAO,GAAG,IAAI,CAAC;AAAA,IACjB;AAEA,WAAO,GAAG,EAAE,KAAK,IAAI;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/array/groupBy.mjs

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

package/dist/array/groupBy.mjs.map

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

package/dist/array/index.d.ts

@@ -1,30 +1,30 @@
-export { chunk } from './chunk';
-export { difference } from './difference';
-export { differenceBy } from './differenceBy';
-export { differenceWith } from './differenceWith';
-export { drop } from './drop';
-export { dropRight } from './dropRight';
-export { dropRightWhile } from './dropRightWhile';
-export { dropWhile } from './dropWhile';
-export { groupBy } from './groupBy';
-export { intersection } from './intersection';
-export { intersectionBy } from './intersectionBy';
-export { intersectionWith } from './intersectionWith';
-export { partition } from './partition';
-export { sample } from './sample';
-export { shuffle } from './shuffle';
-export { take } from './take';
-export { takeRight } from './takeRight';
-export { takeRightWhile } from './takeRightWhile';
-export { takeWhile } from './takeWhile';
-export { union } from './union';
-export { unionBy } from './unionBy';
-export { unionWith } from './unionWith';
-export { uniq } from './uniq';
-export { uniqBy } from './uniqBy';
-export { uniqWith } from './uniqWith';
-export { xor } from './xor';
-export { xorBy } from './xorBy';
-export { xorWith } from './xorWith';
-export { zip } from './zip';
-export { zipWith } from './zipWith';
+export { chunk } from './chunk.js';
+export { difference } from './difference.js';
+export { differenceBy } from './differenceBy.js';
+export { differenceWith } from './differenceWith.js';
+export { drop } from './drop.js';
+export { dropRight } from './dropRight.js';
+export { dropRightWhile } from './dropRightWhile.js';
+export { dropWhile } from './dropWhile.js';
+export { groupBy } from './groupBy.js';
+export { intersection } from './intersection.js';
+export { intersectionBy } from './intersectionBy.js';
+export { intersectionWith } from './intersectionWith.js';
+export { partition } from './partition.js';
+export { sample } from './sample.js';
+export { shuffle } from './shuffle.js';
+export { take } from './take.js';
+export { takeRight } from './takeRight.js';
+export { takeRightWhile } from './takeRightWhile.js';
+export { takeWhile } from './takeWhile.js';
+export { union } from './union.js';
+export { unionBy } from './unionBy.js';
+export { unionWith } from './unionWith.js';
+export { uniq } from './uniq.js';
+export { uniqBy } from './uniqBy.js';
+export { uniqWith } from './uniqWith.js';
+export { xor } from './xor.js';
+export { xorBy } from './xorBy.js';
+export { xorWith } from './xorWith.js';
+export { zip } from './zip.js';
+export { zipWith } from './zipWith.js';