@fedify/fedify 1.6.0-dev.808 → 1.6.0-dev.810

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/index.js

@@ -0,0 +1,60 @@
+export { at } from './at.js';
+export { chunk } from './chunk.js';
+export { compact } from './compact.js';
+export { countBy } from './countBy.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 { fill } from './fill.js';
+export { flatMap } from './flatMap.js';
+export { flatMapDeep } from './flatMapDeep.js';
+export { flatten } from './flatten.js';
+export { flattenDeep } from './flattenDeep.js';
+export { forEachRight } from './forEachRight.js';
+export { groupBy } from './groupBy.js';
+export { head } from './head.js';
+export { initial } from './initial.js';
+export { intersection } from './intersection.js';
+export { intersectionBy } from './intersectionBy.js';
+export { intersectionWith } from './intersectionWith.js';
+export { isSubset } from './isSubset.js';
+export { isSubsetWith } from './isSubsetWith.js';
+export { keyBy } from './keyBy.js';
+export { last } from './last.js';
+export { maxBy } from './maxBy.js';
+export { minBy } from './minBy.js';
+export { orderBy } from './orderBy.js';
+export { partition } from './partition.js';
+export { pull } from './pull.js';
+export { pullAt } from './pullAt.js';
+export { remove } from './remove.js';
+export { sample } from './sample.js';
+export { sampleSize } from './sampleSize.js';
+export { shuffle } from './shuffle.js';
+export { sortBy } from './sortBy.js';
+export { tail } from './tail.js';
+export { take } from './take.js';
+export { takeRight } from './takeRight.js';
+export { takeRightWhile } from './takeRightWhile.js';
+export { takeWhile } from './takeWhile.js';
+export { toFilled } from './toFilled.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 { unzip } from './unzip.js';
+export { unzipWith } from './unzipWith.js';
+export { windowed } from './windowed.js';
+export { without } from './without.js';
+export { xor } from './xor.js';
+export { xorBy } from './xorBy.js';
+export { xorWith } from './xorWith.js';
+export { zip } from './zip.js';
+export { zipObject } from './zipObject.js';
+export { zipWith } from './zipWith.js';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/initial.js

@@ -0,0 +1,16 @@
+/**
+ * Returns a new array containing all elements except the last one from the input array.
+ * If the input array is empty or has only one element, the function returns an empty array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} arr - The input array.
+ * @returns {T[]} A new array containing all but the last element of the input array.
+ *
+ * @example
+ * const arr = [1, 2, 3, 4];
+ * const result = initial(arr);
+ * // result will be [1, 2, 3]
+ */
+export function initial(arr) {
+    return arr.slice(0, -1);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersection.js

@@ -0,0 +1,24 @@
+/**
+ * Returns the intersection of two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements that are
+ * present in both arrays. It effectively filters out any elements from the first array that
+ * are not found in the second array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {T[]} secondArr - The second array to compare.
+ * @returns {T[]} A new array containing the elements that are present in both arrays.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [3, 4, 5, 6, 7];
+ * const result = intersection(array1, array2);
+ * // result will be [3, 4, 5] since these elements are in both arrays.
+ */
+export function intersection(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => {
+        return secondSet.has(item);
+    });
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersectionBy.js

@@ -0,0 +1,37 @@
+/**
+ * Returns the intersection of two arrays based on a mapping function.
+ *
+ * This function takes two arrays and a mapping function. It returns a new array containing
+ * the elements from the first array that, when mapped using the provided function, have matching
+ * mapped elements in the second array. It effectively filters out any elements from the first array
+ * that do not have corresponding mapped values in the second array.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = intersectionBy(array1, array2, mapper);
+ * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element.
+ */
+export function intersectionBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(mapper));
+    return firstArr.filter(item => mappedSecondSet.has(mapper(item)));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/intersectionWith.js

@@ -0,0 +1,41 @@
+/**
+ * Returns the intersection of two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom equality function. It returns a new array containing
+ * the elements from the first array that have matching elements in the second array, as determined
+ * by the custom equality function. It effectively filters out any elements from the first array that
+ * do not have corresponding matches in the second array according to the equality function.
+ *
+ * @template T - The type of elements in the first array.
+ * @template U - The type of elements in the second array.
+ * @param {T[]} firstArr - The first array to compare.
+ * @param {U[]} secondArr - The second array to compare.
+ * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
+ * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
+ * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
+ *
+ * @example
+ * const array1 = [
+ *   { id: 1, name: 'jane' },
+ *   { id: 2, name: 'amy' },
+ *   { id: 3, name: 'michael' },
+ * ];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = intersectionWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
+ */
+export function intersectionWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.some(secondItem => {
+            return areItemsEqual(firstItem, secondItem);
+        });
+    });
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/isSubset.js

@@ -0,0 +1,27 @@
+import { difference } from './difference.js';
+/**
+ * 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
+ * ```
+ */
+export function isSubset(superset, subset) {
+    return difference(subset, superset).length === 0;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/isSubsetWith.js

@@ -0,0 +1,34 @@
+import { differenceWith } from './differenceWith.js';
+/**
+ * Checks if the `subset` array is entirely contained within the `superset` array based on a custom equality function.
+ *
+ * This function takes two arrays and a custom comparison function. It returns a boolean indicating
+ * whether all elements in the subset array are present in the superset array, as determined by the provided
+ * custom equality function.
+ *
+ * @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.
+ * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
+ * @returns {boolean} - Returns `true` if all elements of the subset are present in the superset
+ * according to the custom equality function, otherwise returns `false`.
+ *
+ * @example
+ * ```typescript
+ * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const subset = [{ id: 2 }, { id: 1 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * isSubsetWith(superset, subset, areItemsEqual); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const subset = [{ id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * isSubsetWith(superset, subset, areItemsEqual); // false
+ * ```
+ */
+export function isSubsetWith(superset, subset, areItemsEqual) {
+    return differenceWith(subset, superset, areItemsEqual).length === 0;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/keyBy.js

@@ -0,0 +1,36 @@
+/**
+ * Maps each element 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 the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param {T[]} arr - The array of elements to be mapped.
+ * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
+ * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+export function keyBy(arr, getKeyFromItem) {
+    const result = {};
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        const key = getKeyFromItem(item);
+        result[key] = item;
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/last.js

@@ -0,0 +1,25 @@
+/**
+ * Returns the last element of an array.
+ *
+ * This function takes an array and returns the last element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * 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.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const lastElement = last(arr);
+ * // lastElement will be 3
+ *
+ * const emptyArr: number[] = [];
+ * const noElement = last(emptyArr);
+ * // noElement will be undefined
+ */
+export function last(arr) {
+    return arr[arr.length - 1];
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/maxBy.js

@@ -0,0 +1,37 @@
+/**
+ * Finds the element in an array that has the maximum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function,
+ * or `undefined` if the array is empty.
+ * @example
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
+ * maxBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'john', age: 30 }
+ */
+export function maxBy(items, getValue) {
+    if (items.length === 0) {
+        return undefined;
+    }
+    let maxElement = items[0];
+    let max = getValue(maxElement);
+    for (let i = 1; i < items.length; i++) {
+        const element = items[i];
+        const value = getValue(element);
+        if (value > max) {
+            max = value;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/minBy.js

@@ -0,0 +1,37 @@
+/**
+ * Finds the element in an array that has the minimum value when applying
+ * the `getValue` function to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function,
+ * or `undefined` if the array is empty.
+ * @example
+ * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
+ * minBy([], x => x.a); // Returns: undefined
+ * minBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'joe', age: 26 }
+ */
+export function minBy(items, getValue) {
+    if (items.length === 0) {
+        return undefined;
+    }
+    let minElement = items[0];
+    let min = getValue(minElement);
+    for (let i = 1; i < items.length; i++) {
+        const element = items[i];
+        const value = getValue(element);
+        if (value < min) {
+            min = value;
+            minElement = element;
+        }
+    }
+    return minElement;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/orderBy.js

@@ -0,0 +1,52 @@
+import { compareValues } from '../_internal/compareValues.js';
+/**
+ * Sorts an array of objects based on the given `criteria` and their corresponding order directions.
+ *
+ * - If you provide keys, it sorts the objects by the values of those keys.
+ * - If you provide functions, it sorts based on the values returned by those functions.
+ *
+ * The function returns the array of objects sorted in corresponding order directions.
+ * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
+ * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array of objects to be sorted.
+ * @param {Array<((item: T) => unknown) | keyof T>} criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
+ * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
+ * @returns {T[]} - The sorted array.
+ *
+ * @example
+ * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+ * const users = [
+ *   { user: 'fred', age: 48 },
+ *   { user: 'barney', age: 34 },
+ *   { user: 'fred', age: 40 },
+ *   { user: 'barney', age: 36 },
+ * ];
+ *
+ * const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'fred', age: 48 },
+ * //   { user: 'fred', age: 40 },
+ * // ]
+ */
+export function orderBy(arr, criteria, orders) {
+    return arr.slice().sort((a, b) => {
+        const ordersLength = orders.length;
+        for (let i = 0; i < criteria.length; i++) {
+            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
+            const criterion = criteria[i];
+            const criterionIsFunction = typeof criterion === 'function';
+            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
+            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
+            const result = compareValues(valueA, valueB, order);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    });
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/partition.js

@@ -0,0 +1,36 @@
+/**
+ * Splits an array into two groups based on a predicate function.
+ *
+ * This function takes an array and a predicate function. It returns a tuple of two arrays:
+ * the first array contains elements for which the predicate function returns true, and
+ * the second array contains elements for which the predicate function returns false.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to partition.
+ * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
+ * whether an element should be placed in the truthy array. The function is called with each
+ * element of the array.
+ * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for
+ * which the predicate returned true, and the second array contains elements for which the
+ * predicate returned false.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const isEven = x => x % 2 === 0;
+ * const [even, odd] = partition(array, isEven);
+ * // even will be [2, 4], and odd will be [1, 3, 5]
+ */
+export function partition(arr, isInTruthy) {
+    const truthy = [];
+    const falsy = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (isInTruthy(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/pull.js

@@ -0,0 +1,33 @@
+/**
+ * Removes all specified values from an array.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `difference`.
+ *
+ * @template T, U
+ * @param {T[]} arr - The array to modify.
+ * @param {unknown[]} valuesToRemove - The values to remove from the array.
+ * @returns {T[]} The modified array with the specified values removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5, 2, 4];
+ * pull(numbers, [2, 4]);
+ * console.log(numbers); // [1, 3, 5]
+ */
+export function pull(arr, valuesToRemove) {
+    const valuesSet = new Set(valuesToRemove);
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (valuesSet.has(arr[i])) {
+            continue;
+        }
+        // For handling sparse arrays
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
+    }
+    arr.length = resultIndex;
+    return arr;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/pullAt.js

@@ -0,0 +1,25 @@
+import { at } from './at.js';
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param {T[]} arr - The array from which elements will be removed.
+ * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {Array<T | undefined>} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+export function pullAt(arr, indicesToRemove) {
+    const removed = at(arr, indicesToRemove);
+    const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x));
+    for (const index of indices) {
+        arr.splice(index, 1);
+    }
+    return removed;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/remove.js

@@ -0,0 +1,35 @@
+/**
+ * Removes elements from an array based on a predicate function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove elements without modifying the original array, use `filter`.
+ *
+ * @template T
+ * @param {T[]} arr - The array to modify.
+ * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed.
+ * @returns {T[]} The modified array with the specified elements removed.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * remove(numbers, (value) => value % 2 === 0);
+ * console.log(numbers); // [1, 3, 5]
+ */
+export function remove(arr, shouldRemoveElement) {
+    const originalArr = arr.slice();
+    const removed = [];
+    let resultIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        if (shouldRemoveElement(arr[i], i, originalArr)) {
+            removed.push(arr[i]);
+            continue;
+        }
+        // For handling sparse arrays
+        if (!Object.hasOwn(arr, i)) {
+            delete arr[resultIndex++];
+            continue;
+        }
+        arr[resultIndex++] = arr[i];
+    }
+    arr.length = resultIndex;
+    return removed;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/sample.js

@@ -0,0 +1,18 @@
+/**
+ * Returns a random element from an array.
+ *
+ * This function takes an array and returns a single element selected randomly from the array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to sample from.
+ * @returns {T} A random element from the array.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const randomElement = sample(array);
+ * // randomElement will be one of the elements from the array, selected randomly.
+ */
+export function sample(arr) {
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    return arr[randomIndex];
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/sampleSize.js

@@ -0,0 +1,35 @@
+import { randomInt } from '../math/randomInt.js';
+/**
+ * Returns a sample element array of a specified `size`.
+ *
+ * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
+ *
+ * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to sample from.
+ * @param {number} size - The size of sample.
+ * @returns {T[]} A new array with sample size applied.
+ * @throws {Error} Throws an error if `size` is greater than the length of `array`.
+ *
+ * @example
+ * const result = sampleSize([1, 2, 3], 2)
+ * // result will be an array containing two of the elements from the array.
+ * // [1, 2] or [1, 3] or [2, 3]
+ */
+export 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;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/shuffle.js

@@ -0,0 +1,25 @@
+/**
+ * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
+ *
+ * This function takes an array and returns a new array with its elements shuffled in a random order.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr - The array to shuffle.
+ * @returns {T[]} A new array with its elements shuffled in random order.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const shuffledArray = shuffle(array);
+ * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
+ */
+export function shuffle(arr) {
+    const result = arr.slice();
+    /**
+     * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
+     */
+    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;
+}