es-toolkit 1.13.1 → 1.14.0-dev.397

package/dist/array/index.mjs

@@ -1,211 +1,52 @@
-import "../chunk-DDH7K4QM.mjs";
-import {
-  unzipWith
-} from "../chunk-IFNXROZR.mjs";
-import {
-  without
-} from "../chunk-PYEYV7BY.mjs";
-import {
-  xor
-} from "../chunk-L7FQX5MN.mjs";
-import {
-  xorBy
-} from "../chunk-Q47NGNXT.mjs";
-import {
-  xorWith
-} from "../chunk-QRSJBBFY.mjs";
-import {
-  zip
-} from "../chunk-IDCUZVJL.mjs";
-import {
-  zipObject
-} from "../chunk-6GWEY5EL.mjs";
-import {
-  zipWith
-} from "../chunk-4KYXHZ4R.mjs";
-import {
-  toFilled
-} from "../chunk-OP4OAKQJ.mjs";
-import {
-  union
-} from "../chunk-R6QA7PLZ.mjs";
-import {
-  unionBy
-} from "../chunk-NFS7RWWE.mjs";
-import {
-  unionWith
-} from "../chunk-2ZCITDMK.mjs";
-import {
-  uniq
-} from "../chunk-DVK2N4KC.mjs";
-import {
-  uniqBy
-} from "../chunk-B4COTK4K.mjs";
-import {
-  uniqWith
-} from "../chunk-237HGSZS.mjs";
-import {
-  unzip
-} from "../chunk-UYZKMBDO.mjs";
-import {
-  sample
-} from "../chunk-2KNLZB7V.mjs";
-import {
-  sampleSize
-} from "../chunk-EHSKB6DF.mjs";
-import "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import {
-  shuffle
-} from "../chunk-G7UQ5PUR.mjs";
-import {
-  tail
-} from "../chunk-TJ4Z5I7M.mjs";
-import {
-  take
-} from "../chunk-ME352XO7.mjs";
-import {
-  takeRight
-} from "../chunk-IQLKIDXF.mjs";
-import {
-  takeRightWhile
-} from "../chunk-NTLX2MPV.mjs";
-import {
-  takeWhile
-} from "../chunk-2IXFGSUA.mjs";
-import {
-  intersectionBy
-} from "../chunk-O6UXZR3U.mjs";
-import {
-  intersectionWith
-} from "../chunk-XI7KRD2C.mjs";
-import {
-  keyBy
-} from "../chunk-AJKZMN2V.mjs";
-import {
-  last
-} from "../chunk-KPBQ7OUY.mjs";
-import {
-  maxBy
-} from "../chunk-OOKNBU4V.mjs";
-import {
-  minBy
-} from "../chunk-IJD7FE2Z.mjs";
-import {
-  orderBy
-} from "../chunk-7B7W36UP.mjs";
-import {
-  partition
-} from "../chunk-DN3NOZ3H.mjs";
-import {
-  flattenDeep
-} from "../chunk-ML727RRJ.mjs";
-import {
-  forEachRight
-} from "../chunk-IEA53J7P.mjs";
-import {
-  groupBy
-} from "../chunk-E6E4RZLN.mjs";
-import {
-  head
-} from "../chunk-HM2JT2RX.mjs";
-import {
-  initial
-} from "../chunk-XPSOKBRZ.mjs";
-import {
-  intersection
-} from "../chunk-FVVSE2F2.mjs";
-import {
-  differenceBy
-} from "../chunk-LVWX5B43.mjs";
-import {
-  differenceWith
-} from "../chunk-6NVQAHXP.mjs";
-import {
-  drop
-} from "../chunk-3EZAFZG3.mjs";
-import {
-  dropRight
-} from "../chunk-OXZCMC5I.mjs";
-import {
-  dropRightWhile
-} from "../chunk-M7SBBYV2.mjs";
-import {
-  dropWhile
-} from "../chunk-LJ2C6MVP.mjs";
-import {
-  fill
-} from "../chunk-YFN6KOC4.mjs";
-import {
-  flatMap
-} from "../chunk-UY76KTPE.mjs";
-import {
-  flatten
-} from "../chunk-33MSBDC6.mjs";
-import {
-  chunk
-} from "../chunk-E6C5EZQA.mjs";
-import {
-  compact
-} from "../chunk-DTJJIMKJ.mjs";
-import {
-  countBy
-} from "../chunk-CRSKT4WW.mjs";
-import {
-  difference
-} from "../chunk-JPUKH67K.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  chunk,
-  compact,
-  countBy,
-  difference,
-  differenceBy,
-  differenceWith,
-  drop,
-  dropRight,
-  dropRightWhile,
-  dropWhile,
-  fill,
-  flatMap,
-  flatten,
-  flattenDeep,
-  forEachRight,
-  groupBy,
-  head,
-  initial,
-  intersection,
-  intersectionBy,
-  intersectionWith,
-  keyBy,
-  last,
-  maxBy,
-  minBy,
-  orderBy,
-  partition,
-  sample,
-  sampleSize,
-  shuffle,
-  tail,
-  take,
-  takeRight,
-  takeRightWhile,
-  takeWhile,
-  toFilled,
-  union,
-  unionBy,
-  unionWith,
-  uniq,
-  uniqBy,
-  uniqWith,
-  unzip,
-  unzipWith,
-  without,
-  xor,
-  xorBy,
-  xorWith,
-  zip,
-  zipObject,
-  zipWith
-};
-//# sourceMappingURL=index.mjs.map
+export { chunk } from './chunk.mjs';
+export { compact } from './compact.mjs';
+export { countBy } from './countBy.mjs';
+export { difference } from './difference.mjs';
+export { differenceBy } from './differenceBy.mjs';
+export { differenceWith } from './differenceWith.mjs';
+export { drop } from './drop.mjs';
+export { dropRight } from './dropRight.mjs';
+export { dropRightWhile } from './dropRightWhile.mjs';
+export { dropWhile } from './dropWhile.mjs';
+export { fill } from './fill.mjs';
+export { flatMap } from './flatMap.mjs';
+export { flatten } from './flatten.mjs';
+export { flattenDeep } from './flattenDeep.mjs';
+export { forEachRight } from './forEachRight.mjs';
+export { groupBy } from './groupBy.mjs';
+export { intersection } from './intersection.mjs';
+export { intersectionBy } from './intersectionBy.mjs';
+export { intersectionWith } from './intersectionWith.mjs';
+export { keyBy } from './keyBy.mjs';
+export { maxBy } from './maxBy.mjs';
+export { minBy } from './minBy.mjs';
+export { orderBy } from './orderBy.mjs';
+export { partition } from './partition.mjs';
+export { sample } from './sample.mjs';
+export { sampleSize } from './sampleSize.mjs';
+export { shuffle } from './shuffle.mjs';
+export { take } from './take.mjs';
+export { takeRight } from './takeRight.mjs';
+export { takeRightWhile } from './takeRightWhile.mjs';
+export { takeWhile } from './takeWhile.mjs';
+export { union } from './union.mjs';
+export { unionBy } from './unionBy.mjs';
+export { unionWith } from './unionWith.mjs';
+export { uniq } from './uniq.mjs';
+export { uniqBy } from './uniqBy.mjs';
+export { uniqWith } from './uniqWith.mjs';
+export { unzip } from './unzip.mjs';
+export { unzipWith } from './unzipWith.mjs';
+export { xor } from './xor.mjs';
+export { xorBy } from './xorBy.mjs';
+export { xorWith } from './xorWith.mjs';
+export { zip } from './zip.mjs';
+export { zipObject } from './zipObject.mjs';
+export { zipWith } from './zipWith.mjs';
+export { without } from './without.mjs';
+export { head } from './head.mjs';
+export { isSubset } from './isSubset.mjs';
+export { tail } from './tail.mjs';
+export { toFilled } from './toFilled.mjs';
+export { last } from './last.mjs';
+export { initial } from './initial.mjs';

package/dist/array/initial.mjs

@@ -1,8 +1,8 @@
-import {
-  initial
-} from "../chunk-XPSOKBRZ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  initial
-};
-//# sourceMappingURL=initial.mjs.map
+function initial(arr) {
+    if (arr.length <= 1) {
+        return [];
+    }
+    return arr.slice(0, -1);
+}
+
+export { initial };

package/dist/array/intersection.mjs

@@ -1,8 +1,8 @@
-import {
-  intersection
-} from "../chunk-FVVSE2F2.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  intersection
-};
-//# sourceMappingURL=intersection.mjs.map
+function intersection(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => {
+        return secondSet.has(item);
+    });
+}
+
+export { intersection };

package/dist/array/intersectionBy.mjs

@@ -1,8 +1,6 @@
-import {
-  intersectionBy
-} from "../chunk-O6UXZR3U.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  intersectionBy
-};
-//# sourceMappingURL=intersectionBy.mjs.map
+function intersectionBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(mapper));
+    return firstArr.filter(item => mappedSecondSet.has(mapper(item)));
+}
+
+export { intersectionBy };

package/dist/array/intersectionWith.mjs

@@ -1,8 +1,9 @@
-import {
-  intersectionWith
-} from "../chunk-XI7KRD2C.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  intersectionWith
-};
-//# sourceMappingURL=intersectionWith.mjs.map
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.some(secondItem => {
+            return areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+export { intersectionWith };

package/dist/array/isSubset.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Checks if the `subset` array is entirely contained within the `superset` array.
+ *
+ *
+ * @template T - The type of elements contained in the arrays.
+ * @param {T[]} superset - The array that may contain all elements of the subset.
+ * @param {T[]} subset - The array to check against the superset.
+ * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`.
+ *
+ * @example
+ * ```typescript
+ * const superset = [1, 2, 3, 4, 5];
+ * const subset = [2, 3, 4];
+ * isSubset(superset, subset); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const superset = ['a', 'b', 'c'];
+ * const subset = ['a', 'd'];
+ * isSubset(superset, subset); // false
+ * ```
+ */
+declare function isSubset<T>(superset: readonly T[], subset: readonly T[]): boolean;
+
+export { isSubset };

package/dist/array/isSubset.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Checks if the `subset` array is entirely contained within the `superset` array.
+ *
+ *
+ * @template T - The type of elements contained in the arrays.
+ * @param {T[]} superset - The array that may contain all elements of the subset.
+ * @param {T[]} subset - The array to check against the superset.
+ * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`.
+ *
+ * @example
+ * ```typescript
+ * const superset = [1, 2, 3, 4, 5];
+ * const subset = [2, 3, 4];
+ * isSubset(superset, subset); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const superset = ['a', 'b', 'c'];
+ * const subset = ['a', 'd'];
+ * isSubset(superset, subset); // false
+ * ```
+ */
+declare function isSubset<T>(superset: readonly T[], subset: readonly T[]): boolean;
+
+export { isSubset };

package/dist/array/isSubset.mjs

@@ -0,0 +1,7 @@
+import { difference } from './difference.mjs';
+
+function isSubset(superset, subset) {
+    return difference(subset, superset).length === 0;
+}
+
+export { isSubset };

package/dist/array/keyBy.mjs

@@ -1,8 +1,10 @@
-import {
-  keyBy
-} from "../chunk-AJKZMN2V.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  keyBy
-};
-//# sourceMappingURL=keyBy.mjs.map
+function keyBy(arr, getKeyFromItem) {
+    const result = {};
+    for (const item of arr) {
+        const key = getKeyFromItem(item);
+        result[key] = item;
+    }
+    return result;
+}
+
+export { keyBy };

package/dist/array/last.d.mts

@@ -7,6 +7,7 @@
  * Unlike some implementations, this function is optimized for performance
  * by directly accessing the last index of the array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to get the last element.
  * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
  *

package/dist/array/last.d.ts

@@ -7,6 +7,7 @@
  * Unlike some implementations, this function is optimized for performance
  * by directly accessing the last index of the array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array from which to get the last element.
  * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
  *

package/dist/array/last.mjs

@@ -1,8 +1,5 @@
-import {
-  last
-} from "../chunk-KPBQ7OUY.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  last
-};
-//# sourceMappingURL=last.mjs.map
+function last(arr) {
+    return arr[arr.length - 1];
+}
+
+export { last };

package/dist/array/maxBy.mjs

@@ -1,8 +1,14 @@
-import {
-  maxBy
-} from "../chunk-OOKNBU4V.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  maxBy
-};
-//# sourceMappingURL=maxBy.mjs.map
+function maxBy(items, getValue) {
+    let maxElement = items[0];
+    let max = -Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value > max) {
+            max = value;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}
+
+export { maxBy };

package/dist/array/minBy.mjs

@@ -1,8 +1,14 @@
-import {
-  minBy
-} from "../chunk-IJD7FE2Z.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  minBy
-};
-//# sourceMappingURL=minBy.mjs.map
+function minBy(items, getValue) {
+    let minElement = items[0];
+    let min = Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value < min) {
+            min = value;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+export { minBy };

package/dist/array/orderBy.mjs

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

package/dist/array/partition.mjs

@@ -1,8 +1,15 @@
-import {
-  partition
-} from "../chunk-DN3NOZ3H.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  partition
-};
-//# sourceMappingURL=partition.mjs.map
+function partition(arr, isInTruthy) {
+    const truthy = [];
+    const falsy = [];
+    for (const item of arr) {
+        if (isInTruthy(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}
+
+export { partition };

package/dist/array/sample.mjs

@@ -1,8 +1,6 @@
-import {
-  sample
-} from "../chunk-2KNLZB7V.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  sample
-};
-//# sourceMappingURL=sample.mjs.map
+function sample(arr) {
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    return arr[randomIndex];
+}
+
+export { sample };

package/dist/array/sampleSize.mjs

@@ -1,10 +1,20 @@
-import {
-  sampleSize
-} from "../chunk-EHSKB6DF.mjs";
-import "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  sampleSize
-};
-//# sourceMappingURL=sampleSize.mjs.map
+import { randomInt } from '../math/randomInt.mjs';
+
+function sampleSize(array, size) {
+    if (size > array.length) {
+        throw new Error('Size must be less than or equal to the length of array.');
+    }
+    const result = new Array(size);
+    const selected = new Set();
+    for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
+        let index = randomInt(0, step + 1);
+        if (selected.has(index)) {
+            index = step;
+        }
+        selected.add(index);
+        result[resultIndex] = array[index];
+    }
+    return result;
+}
+
+export { sampleSize };

package/dist/array/shuffle.mjs

@@ -1,8 +1,10 @@
-import {
-  shuffle
-} from "../chunk-G7UQ5PUR.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  shuffle
-};
-//# sourceMappingURL=shuffle.mjs.map
+function shuffle(arr) {
+    const result = arr.slice();
+    for (let i = result.length - 1; i >= 1; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
+
+export { shuffle };

package/dist/array/tail.d.mts

@@ -1,7 +1,8 @@
 /**
  * Returns an empty array when the input is a single-element array.
  *
- * @param {readonly [T]} arr - The single-element array to process.
+ * @template T - The type of the single element in the array.
+ * @param {[T]} arr - The single-element array to process.
  * @returns {[]} An empty array.
  *
  * @example
@@ -13,7 +14,8 @@ declare function tail<T>(arr: readonly [T]): [];
 /**
  * Returns an empty array when the input is an empty array.
  *
- * @param {readonly []} arr - The empty array to process.
+ * @template T - The type of elements in the array.
+ * @param {[]} arr - The empty array to process.
  * @returns {[]} An empty array.
  *
  * @example
@@ -25,7 +27,9 @@ declare function tail(arr: readonly []): [];
 /**
  * Returns a new array with all elements except for the first when the input is a tuple array.
  *
- * @param {readonly [T, ...U[]]} arr - The tuple array to process.
+ * @template T - The type of the first element in the tuple array.
+ * @template U - The type of the remaining elements in the tuple array.
+ * @param {[T, ...U[]]} arr - The tuple array to process.
  * @returns {U[]} A new array containing all elements of the input array except for the first one.
  *
  * @example
@@ -41,7 +45,8 @@ declare function tail<T, U>(arr: readonly [T, ...U[]]): U[];
  * except for the first one. If the input array is empty or has only one element,
  * an empty array is returned.
  *
- * @param {readonly T[]} arr - The array to get the tail of.
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to get the tail of.
  * @returns {T[]} A new array containing all elements of the input array except for the first one.
  *
  * @example