es-toolkit 1.0.3-dev.37 → 1.0.3

package/dist/predicate/index.js

@@ -1,56 +1,98 @@
-"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);
+'use strict';
 
-// src/predicate/index.ts
-var predicate_exports = {};
-__export(predicate_exports, {
-  isNil: () => isNil,
-  isNotNil: () => isNotNil,
-  isNull: () => isNull,
-  isUndefined: () => isUndefined
-});
-module.exports = __toCommonJS(predicate_exports);
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/predicate/isNil.ts
+/**
+ * Checks if a given value is null or undefined.
+ * 
+ * This function tests whether the provided value is either `null` or `undefined`. 
+ * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
+ * 
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
+ *
+ * @param {unknown} x - The value to test for null or undefined.
+ * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
+ *
+ * @example
+ *  * const value1 = null;
+ * const value2 = undefined;
+ * const value3 = 42;
+ * const result1 = isNil(value1); // true
+ * const result2 = isNil(value2); // true
+ * const result3 = isNil(value3); // false
+ */
 function isNil(x) {
-  return x == null || x == void 0;
+  return x == null || x == undefined;
 }
 
-// src/predicate/isNotNil.ts
+/**
+ * Checks if the given value is not null nor undefined.
+ * 
+ * The main use of this function is to be used with TypeScript as a type predicate.
+ *
+ * @param {T | null | undefined} x - The value to test if it is not null nor undefined.
+ * @returns {x is T} True if the value is not null nor undefined, false otherwise.
+ *
+ * @example
+ * // Here the type of `arr` is (number | undefined)[]
+ * const arr = [1, undefined, 3];
+ * // Here the type of `result` is number[]
+ * const result = arr.filter(isNotNil);
+ * // result will be [1, 3]
+ */
 function isNotNil(x) {
-  return x != null && x != void 0;
+  return x != null && x != undefined;
 }
 
-// src/predicate/isNull.ts
+/**
+ * Checks if the given value is null.
+ *
+ * This function tests whether the provided value is strictly equal to `null`. 
+ * It returns `true` if the value is `null`, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.
+ * 
+ * @param {unknown} x - The value to test if it is null.
+ * @returns {x is null} True if the value is null, false otherwise.
+ *
+ * @example
+ *  * const value1 = null;
+ * const value2 = undefined;
+ * const value3 = 42;
+ * 
+ * console.log(isNull(value1)); // true
+ * console.log(isNull(value2)); // false
+ * console.log(isNull(value3)); // false
+ */
 function isNull(x) {
   return x === null;
 }
 
-// src/predicate/isUndefined.ts
+/**
+ * Checks if the given value is undefined.
+ *
+ * This function tests whether the provided value is strictly equal to `undefined`. 
+ * It returns `true` if the value is `undefined`, and `false` otherwise.
+ * 
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`.
+ *
+ * @param {unknown} x - The value to test if it is undefined.
+ * @returns {x is undefined} true if the value is undefined, false otherwise.
+ *
+ * @example
+ *  * const value1 = undefined;
+ * const value2 = null;
+ * const value3 = 42;
+ * 
+ * console.log(isUndefined(value1)); // true
+ * console.log(isUndefined(value2)); // false
+ * console.log(isUndefined(value3)); // false
+ */
 function isUndefined(x) {
-  return x === void 0;
+  return x === undefined;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isNil,
-  isNotNil,
-  isNull,
-  isUndefined
-});
-//# sourceMappingURL=index.js.map
+
+exports.isNil = isNil;
+exports.isNotNil = isNotNil;
+exports.isNull = isNull;
+exports.isUndefined = isUndefined;

package/dist/predicate/isNil.d.ts

@@ -17,6 +17,4 @@
  * const result2 = isNil(value2); // true
  * const result3 = isNil(value3); // false
  */
-declare function isNil(x: unknown): x is null | undefined;
-
-export { isNil };
+export declare function isNil(x: unknown): x is null | undefined;

package/dist/predicate/isNil.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/predicate/isNotNil.d.ts

@@ -13,6 +13,4 @@
  * const result = arr.filter(isNotNil);
  * // result will be [1, 3]
  */
-declare function isNotNil<T>(x: T | null | undefined): x is T;
-
-export { isNotNil };
+export declare function isNotNil<T>(x: T | null | undefined): x is T;

package/dist/predicate/isNotNil.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/predicate/isNull.d.ts

@@ -18,6 +18,4 @@
  * console.log(isNull(value2)); // false
  * console.log(isNull(value3)); // false
  */
-declare function isNull(x: unknown): x is null;
-
-export { isNull };
+export declare function isNull(x: unknown): x is null;

package/dist/predicate/isNull.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/predicate/isUndefined.d.ts

@@ -18,6 +18,4 @@
  * console.log(isUndefined(value2)); // false
  * console.log(isUndefined(value3)); // false
  */
-declare function isUndefined(x: unknown): x is undefined;
-
-export { isUndefined };
+export declare function isUndefined(x: unknown): x is undefined;

package/dist/predicate/isUndefined.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/promise/delay.d.ts

@@ -16,6 +16,4 @@
  *
  * foo();
  */
-declare function delay(ms: number): Promise<void>;
-
-export { delay };
+export declare function delay(ms: number): Promise<void>;

package/dist/promise/delay.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/promise/index.d.ts

@@ -1 +1 @@
-export { delay } from './delay.js';
+export { delay } from './delay';

package/dist/promise/index.js

@@ -1,37 +1,29 @@
-"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);
+'use strict';
 
-// src/promise/index.ts
-var promise_exports = {};
-__export(promise_exports, {
-  delay: () => delay
-});
-module.exports = __toCommonJS(promise_exports);
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/promise/delay.ts
+/**
+ * Delays the execution of code for a specified number of milliseconds.
+ * 
+ * This function returns a Promise that resolves after the specified delay, allowing you to use it 
+ * with async/await to pause execution.
+ *
+ * @param {number} ms - The number of milliseconds to delay.
+ * @returns {Promise<void>} A Promise that resolves after the specified delay.
+ *
+ * @example
+ * async function foo() {
+ *   console.log('Start');
+ *   await delay(1000); // Delays execution for 1 second
+ *   console.log('End');
+ * }
+ * 
+ * foo();
+ */
 function delay(ms) {
-  return new Promise((resolve) => {
+  return new Promise(function (resolve) {
     setTimeout(resolve, ms);
   });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  delay
-});
-//# sourceMappingURL=index.js.map
+
+exports.delay = delay;

package/esm/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,163 @@
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _createForOfIteratorHelper as createForOfIteratorHelper, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectSpread2 as objectSpread2, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };

package/esm/array/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,78 @@
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithoutHoles as arrayWithoutHoles, _createForOfIteratorHelper as createForOfIteratorHelper, _iterableToArray as iterableToArray, _nonIterableSpread as nonIterableSpread, _toConsumableArray as toConsumableArray, _unsupportedIterableToArray as unsupportedIterableToArray };

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

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

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

@@ -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,6 +20,10 @@
  * 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.
  */
-declare function difference<T>(firstArr: T[], secondArr: T[]): T[];
+function difference(firstArr, secondArr) {
+  return firstArr.filter(function (item) {
+    return !secondArr.includes(item);
+  });
+}
 
 export { difference };

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

@@ -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,6 +23,13 @@
  * 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.
  */
-declare function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];
+function differenceBy(firstArr, secondArr, mapper) {
+  var mappedSecondArr = secondArr.map(function (item) {
+    return mapper(item);
+  });
+  return firstArr.filter(function (item) {
+    return !mappedSecondArr.includes(mapper(item));
+  });
+}
 
 export { differenceBy };

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

@@ -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,6 +19,12 @@
  * 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.
  */
-declare function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+  return firstArr.filter(function (firstItem) {
+    return secondArr.every(function (secondItem) {
+      return !areItemsEqual(firstItem, secondItem);
+    });
+  });
+}
 
 export { differenceWith };

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

@@ -1,18 +1,20 @@
 /**
  * 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.
  */
-declare function drop<T>(arr: T[], itemsCount: number): T[];
+function drop(arr, itemsCount) {
+  return arr.slice(itemsCount);
+}
 
 export { drop };