es-toolkit 1.0.3 → 1.0.4-dev.41

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # es-toolkit Changelog
 
+## Version v1.0.4
+
+Released on June 4th, 2024.
+
+- Provide correct type declarations for ECMAScript Modules. (https://github.com/toss/es-toolkit/pull/21)
+
 ## Version v1.0.3
 
 Released on June 3rd, 2024.

package/README.md

@@ -12,7 +12,6 @@ es-toolkit is a state-of-the-art, high-performance JavaScript utility library wi
 - es-toolkit includes built-in TypeScript support, with straightforward yet robust types. It also provides useful type guards such as [isNotNil](https://es-toolkit.slash.page/reference/predicate/isNotNil.html).
 - es-toolkit is battle-tested with 100% test coverage, ensuring reliability and robustness.
 
-
 ## Contributing
 
 We welcome contribution from everyone in the community. Read below for detailed contribution guide.

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

@@ -21,18 +21,6 @@
  * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
  * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
  */
-function chunk(arr, size) {
-  if (!Number.isInteger(size) || size <= 0) {
-    throw new Error('Size must be an integer greater than zero.');
-  }
-  var chunkLength = Math.ceil(arr.length / size);
-  var result = Array(chunkLength);
-  for (var index = 0; index < chunkLength; index++) {
-    var start = index * size;
-    var end = start + size;
-    result[index] = arr.slice(start, end);
-  }
-  return result;
-}
+declare function chunk<T>(arr: T[], size: number): T[][];
 
 export { chunk };

package/dist/array/chunk.d.ts

@@ -21,4 +21,6 @@
  * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
  * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
  */
-export declare function chunk<T>(arr: T[], size: number): T[][];
+declare function chunk<T>(arr: T[], size: number): T[][];
+
+export { chunk };

package/dist/array/chunk.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/chunk.ts
+var chunk_exports = {};
+__export(chunk_exports, {
+  chunk: () => chunk
+});
+module.exports = __toCommonJS(chunk_exports);
+function chunk(arr, size) {
+  if (!Number.isInteger(size) || size <= 0) {
+    throw new Error("Size must be an integer greater than zero.");
+  }
+  const chunkLength = Math.ceil(arr.length / size);
+  const result = Array(chunkLength);
+  for (let index = 0; index < chunkLength; index++) {
+    const start = index * size;
+    const end = start + size;
+    result[index] = arr.slice(start, end);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunk
+});
+//# sourceMappingURL=chunk.js.map

package/dist/array/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/chunk.ts"],"sourcesContent":["/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: T[], size: number): T[][] {\n  if (!Number.isInteger(size) || size <= 0) {\n    throw new Error('Size must be an integer greater than zero.');\n  }\n\n  const chunkLength = Math.ceil(arr.length / size);\n  const result: T[][] = Array(chunkLength);\n\n  for (let index = 0; index < chunkLength; index++) {\n    const start = index * size;\n    const end = start + size;\n\n    result[index] = arr.slice(start, end);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBO,SAAS,MAAS,KAAU,MAAqB;AACtD,MAAI,CAAC,OAAO,UAAU,IAAI,KAAK,QAAQ,GAAG;AACxC,UAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AAEA,QAAM,cAAc,KAAK,KAAK,IAAI,SAAS,IAAI;AAC/C,QAAM,SAAgB,MAAM,WAAW;AAEvC,WAAS,QAAQ,GAAG,QAAQ,aAAa,SAAS;AAChD,UAAM,QAAQ,QAAQ;AACtB,UAAM,MAAM,QAAQ;AAEpB,WAAO,KAAK,IAAI,IAAI,MAAM,OAAO,GAAG;AAAA,EACtC;AAEA,SAAO;AACT;","names":[]}

package/dist/array/chunk.mjs

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

package/dist/array/chunk.mjs.map

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

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

@@ -1,17 +1,17 @@
 /**
  * Computes the difference between two arrays.
- * 
- * This function takes two arrays and returns a new array containing the elements 
- * that are present in the first array but not in the second array. It effectively 
+ *
+ * This function takes two arrays and returns a new array containing the elements
+ * that are present in the first array but not in the second array. It effectively
  * filters out any elements from the first array that also appear in the second array.
  *
  * @template T
- * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array 
+ * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array
  * from which elements will be compared and filtered.
- * @param {T[]} secondArr - The array containing elements to be excluded from the first array. 
- * Each element in this array will be checked against the first array, and if a match is found, 
+ * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
+ * Each element in this array will be checked against the first array, and 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 first array but not 
+ * @returns {T[]} A new array containing the elements that are present in the first array but not
  * in the second array.
  *
  * @example
@@ -20,10 +20,6 @@
  * const result = difference(array1, array2);
  * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
  */
-function difference(firstArr, secondArr) {
-  return firstArr.filter(function (item) {
-    return !secondArr.includes(item);
-  });
-}
+declare function difference<T>(firstArr: T[], secondArr: T[]): T[];
 
 export { difference };

package/dist/array/difference.d.ts

@@ -20,4 +20,6 @@
  * const result = difference(array1, array2);
  * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
  */
-export declare function difference<T>(firstArr: T[], secondArr: T[]): T[];
+declare function difference<T>(firstArr: T[], secondArr: T[]): T[];
+
+export { difference };

package/dist/array/difference.js

@@ -0,0 +1,35 @@
+"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/difference.ts
+var difference_exports = {};
+__export(difference_exports, {
+  difference: () => difference
+});
+module.exports = __toCommonJS(difference_exports);
+function difference(firstArr, secondArr) {
+  return firstArr.filter((item) => {
+    return !secondArr.includes(item);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  difference
+});
+//# sourceMappingURL=difference.js.map

package/dist/array/difference.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/difference.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements\n * that are present in the first array but not in the second array. It effectively\n * filters out any elements from the first array that also appear in the second array.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array\n * from which elements will be compared and filtered.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array.\n * Each element in this array will be checked against the first array, and if a match is found,\n * that element will be excluded from the result.\n * @returns {T[]} A new array containing the elements that are present in the first array but not\n * in the second array.\n *\n * @example\n *  * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [2, 4];\n * const result = difference(array1, array2);\n * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.\n */\nexport function difference<T>(firstArr: T[], secondArr: T[]): T[] {\n  return firstArr.filter(item => {\n    return !secondArr.includes(item);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,SAAS,WAAc,UAAe,WAAqB;AAChE,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,CAAC,UAAU,SAAS,IAAI;AAAA,EACjC,CAAC;AACH;","names":[]}

package/dist/array/difference.mjs

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

package/dist/array/difference.mjs.map

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

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

@@ -1,19 +1,19 @@
 /**
  * Computes the difference between two arrays after mapping their elements through a provided function.
- * 
- * This function takes two arrays and a mapper function. It returns a new array containing the elements 
- * that are present in the first array but not in the second array, based on the identity calculated 
- * by the mapper function. 
- * 
- * Essentially, it filters out any elements from the first array that, when 
+ *
+ * This function takes two arrays and a mapper function. It returns a new array containing the elements
+ * that are present in the first array but not in the second array, based on the identity calculated
+ * by the mapper function.
+ *
+ * Essentially, it filters out any elements from the first array that, when
  * mapped, match an element in the mapped version of the second array.
  *
  * @template T, U
- * @param {T[]} firstArr - The primary array from which to derive the difference. 
+ * @param {T[]} firstArr - The primary array from which to derive the difference.
  * @param {T[]} secondArr - The array containing elements to be excluded from the first array.
- * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function 
+ * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function
  * is applied to each element in both arrays, and the comparison is made based on the mapped values.
- * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding 
+ * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
  * mapped identity in the second array.
  *
  * @example
@@ -23,13 +23,6 @@
  * const result = differenceBy(array1, array2, mapper);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
  */
-function differenceBy(firstArr, secondArr, mapper) {
-  var mappedSecondArr = secondArr.map(function (item) {
-    return mapper(item);
-  });
-  return firstArr.filter(function (item) {
-    return !mappedSecondArr.includes(mapper(item));
-  });
-}
+declare function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];
 
 export { differenceBy };

package/dist/array/differenceBy.d.ts

@@ -23,4 +23,6 @@
  * const result = differenceBy(array1, array2, mapper);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
  */
-export declare function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];
+declare function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];
+
+export { differenceBy };

package/dist/array/differenceBy.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/differenceBy.ts
+var differenceBy_exports = {};
+__export(differenceBy_exports, {
+  differenceBy: () => differenceBy
+});
+module.exports = __toCommonJS(differenceBy_exports);
+function differenceBy(firstArr, secondArr, mapper) {
+  const mappedSecondArr = secondArr.map((item) => mapper(item));
+  return firstArr.filter((item) => {
+    return !mappedSecondArr.includes(mapper(item));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  differenceBy
+});
+//# sourceMappingURL=differenceBy.js.map

package/dist/array/differenceBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/differenceBy.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays after mapping their elements through a provided function.\n *\n * This function takes two arrays and a mapper function. It returns a new array containing the elements\n * that are present in the first array but not in the second array, based on the identity calculated\n * by the mapper function.\n *\n * Essentially, it filters out any elements from the first array that, when\n * mapped, match an element in the mapped version of the second array.\n *\n * @template T, U\n * @param {T[]} firstArr - The primary array from which to derive the difference.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array.\n * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function\n * is applied to each element in both arrays, and the comparison is made based on the mapped values.\n * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding\n * mapped identity in the second array.\n *\n * @example\n *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const mapper = item => item.id;\n * const result = differenceBy(array1, array2, mapper);\n * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.\n */\nexport function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[] {\n  const mappedSecondArr = secondArr.map(item => mapper(item));\n\n  return firstArr.filter(item => {\n    return !mappedSecondArr.includes(mapper(item));\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBO,SAAS,aAAmB,UAAe,WAAgB,QAA8B;AAC9F,QAAM,kBAAkB,UAAU,IAAI,UAAQ,OAAO,IAAI,CAAC;AAE1D,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,CAAC,gBAAgB,SAAS,OAAO,IAAI,CAAC;AAAA,EAC/C,CAAC;AACH;","names":[]}

package/dist/array/differenceBy.mjs

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

package/dist/array/differenceBy.mjs.map

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

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

@@ -1,15 +1,15 @@
 /**
  * Computes the difference between two arrays based on a custom equality function.
- * 
- * This function takes two arrays and a custom comparison function. It returns a new array containing 
- * the elements that are present in the first array but not in the second array. The comparison to determine 
+ *
+ * This function takes two arrays and a custom comparison function. It returns a new array containing
+ * the elements that are present in the first array but not in the second array. The comparison to determine
  * if elements are equal is made using the provided custom function.
  *
  * @template T
  * @param {T[]} firstArr - The array from which to get the difference.
- * @param {T[]} secondArr - The array containing elements to exclude from the first array. 
+ * @param {T[]} secondArr - The array containing elements to exclude from the first array.
  * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
- * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array 
+ * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array
  * according to the custom equality function.
  *
  * @example
@@ -19,12 +19,6 @@
  * const result = differenceWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
  */
-function differenceWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter(function (firstItem) {
-    return secondArr.every(function (secondItem) {
-      return !areItemsEqual(firstItem, secondItem);
-    });
-  });
-}
+declare function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
 
 export { differenceWith };

package/dist/array/differenceWith.d.ts

@@ -19,4 +19,6 @@
  * const result = differenceWith(array1, array2, areItemsEqual);
  * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
  */
-export declare function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+declare function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+
+export { differenceWith };

package/dist/array/differenceWith.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/differenceWith.ts
+var differenceWith_exports = {};
+__export(differenceWith_exports, {
+  differenceWith: () => differenceWith
+});
+module.exports = __toCommonJS(differenceWith_exports);
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter((firstItem) => {
+    return secondArr.every((secondItem) => {
+      return !areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  differenceWith
+});
+//# sourceMappingURL=differenceWith.js.map

package/dist/array/differenceWith.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/differenceWith.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays based on a custom equality function.\n *\n * This function takes two arrays and a custom comparison function. It returns a new array containing\n * the elements that are present in the first array but not in the second array. The comparison to determine\n * if elements are equal is made using the provided custom function.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to get the difference.\n * @param {T[]} secondArr - The array containing elements to exclude from the first array.\n * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.\n * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array\n * according to the custom equality function.\n *\n * @example\n *  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const areItemsEqual = (a, b) => a.id === b.id;\n * const result = differenceWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.\n */\nexport function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[] {\n  return firstArr.filter(firstItem => {\n    return secondArr.every(secondItem => {\n      return !areItemsEqual(firstItem, secondItem);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,eAAkB,UAAe,WAAgB,eAA6C;AAC5G,SAAO,SAAS,OAAO,eAAa;AAClC,WAAO,UAAU,MAAM,gBAAc;AACnC,aAAO,CAAC,cAAc,WAAW,UAAU;AAAA,IAC7C,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/dist/array/differenceWith.mjs

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

package/dist/array/differenceWith.mjs.map

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

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

@@ -1,20 +1,18 @@
 /**
  * Removes a specified number of elements from the beginning of an array and returns the rest.
- * 
- * This function takes an array and a number, and returns a new array with the specified number 
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
  * of elements removed from the start.
  *
  * @param {T[]} arr - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
  * @returns {T[]} A new array with the specified number of elements removed from the start.
- * 
+ *
  * @example
  *  * const array = [1, 2, 3, 4, 5];
  * const result = drop(array, 2);
  * // result will be [3, 4, 5] since the first two elements are dropped.
  */
-function drop(arr, itemsCount) {
-  return arr.slice(itemsCount);
-}
+declare function drop<T>(arr: T[], itemsCount: number): T[];
 
 export { drop };

package/dist/array/drop.d.ts

@@ -13,4 +13,6 @@
  * const result = drop(array, 2);
  * // result will be [3, 4, 5] since the first two elements are dropped.
  */
-export declare function drop<T>(arr: T[], itemsCount: number): T[];
+declare function drop<T>(arr: T[], itemsCount: number): T[];
+
+export { drop };

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

package/dist/array/drop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/drop.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the beginning of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the start.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the beginning of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the start.\n *\n * @example\n *  * const array = [1, 2, 3, 4, 5];\n * const result = drop(array, 2);\n * // result will be [3, 4, 5] since the first two elements are dropped.\n */\nexport function drop<T>(arr: T[], itemsCount: number): T[] {\n  return arr.slice(itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,SAAS,KAAQ,KAAU,YAAyB;AACzD,SAAO,IAAI,MAAM,UAAU;AAC7B;","names":[]}

package/dist/array/drop.mjs

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

package/dist/array/drop.mjs.map

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

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

@@ -1,7 +1,7 @@
 /**
  * Removes a specified number of elements from the end of an array and returns the rest.
- * 
- * This function takes an array and a number, and returns a new array with the specified number 
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
  * of elements removed from the end.
  *
  * @param {T[]} arr - The array from which to drop elements.
@@ -13,8 +13,6 @@
  * const result = dropRight(array, 2);
  * // result will be [1, 2, 3] since the last two elements are dropped.
  */
-function dropRight(arr, itemsCount) {
-  return arr.slice(0, -itemsCount);
-}
+declare function dropRight<T>(arr: T[], itemsCount: number): T[];
 
 export { dropRight };

package/dist/array/dropRight.d.ts

@@ -13,4 +13,6 @@
  * const result = dropRight(array, 2);
  * // result will be [1, 2, 3] since the last two elements are dropped.
  */
-export declare function dropRight<T>(arr: T[], itemsCount: number): T[];
+declare function dropRight<T>(arr: T[], itemsCount: number): T[];
+
+export { dropRight };

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

package/dist/array/dropRight.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/dropRight.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the end of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the end.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the end of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the end.\n *\n * @example\n *  * const array = [1, 2, 3, 4, 5];\n * const result = dropRight(array, 2);\n * // result will be [1, 2, 3] since the last two elements are dropped.\n */\nexport function dropRight<T>(arr: T[], itemsCount: number): T[] {\n  return arr.slice(0, -itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,SAAS,UAAa,KAAU,YAAyB;AAC9D,SAAO,IAAI,MAAM,GAAG,CAAC,UAAU;AACjC;","names":[]}

package/dist/array/dropRight.mjs

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

package/dist/array/dropRight.mjs.map

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

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

@@ -1,14 +1,12 @@
-import { dropWhile } from './dropWhile.mjs';
-
 /**
  * Removes elements from the end of an array until the predicate returns false.
- * 
- * This function iterates over an array from the end and drops elements until the provided 
+ *
+ * This function iterates over an array from the end and drops elements 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 {function(item: T): boolean} canContinueDropping - A predicate function that determines 
- * whether to continue dropping elements. The function is called with each element from the end, 
+ * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines
+ * whether to continue dropping elements. The function is called with each element from the end,
  * and dropping continues as long as it returns true.
  * @returns {T[]} A new array with the elements remaining after the predicate returns false.
  *
@@ -17,10 +15,6 @@ import { dropWhile } from './dropWhile.mjs';
  * const result = dropRightWhile(array, x => x > 3);
  * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.
  */
-function dropRightWhile(arr, canContinueDropping) {
-  var reversed = arr.slice().reverse();
-  var dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
-}
+declare function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
 
 export { dropRightWhile };